JP2008146162A - Canonical representation generation device and method and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To efficiently generate canonical representation for retrieving attribute values in a fixed range. <P>SOLUTION: An arithmetic part 102 calculates a first value whose most significant digit has the same value as the lower limit value shown by attribute range condition data, and whose other digits have the maximum values of each digit and a second value whose most significant value has the same value as the upper limit value shown by the attribute range condition data, and whose other digits have the minimum values of each digit on the basis of a format shown by attribute range condition data input by an attribute range condition input part 101. A canonical representation generation part 104 generates low order region data showing attribute values from the lower limit value to the first value with canonical representation and high order region data showing attribute values from the second value to the upper limit value as canonical representation, and when any attribute value exists between the first value and the second value, generates middle order region data showing the attribute value as canonical representation. A canonical representation connection part 105 connects the low order region data, the high order region data and the middle order region data. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  The present invention relates to a regular expression generation device, a regular expression generation method, and a regular expression generation program. In particular, the present invention relates to a search condition generation device, a search condition generation method, and a search condition generation program using regular expressions.

  The search conditions (keywords) entered for the search are converted to regular expressions so that they can be searched with different or similar notations, and the search target includes typographical errors and line feed codes. A technique for making it possible to perform a search even in the case where the information is stored is known (for example, see Patent Document 1).

As a search target, for example, a database for storing logs can be cited. In recent years, logs have become diversified and large-scaled, and the need for a log-dedicated database management system for efficiently managing logs is increasing (see, for example, Non-Patent Document 1).
Japanese Patent Laid-Open No. 7-121547 Takaaki Nakamura and 3 others, “Realization of a large-scale log database”, Proc. Of the 68th (2006) National Convention, IPSJ, pp. 29-30, March 2006

  The movement of collecting, storing and analyzing logs is progressing mainly in the field of information security. The logs used here include the operation history and access history of information devices such as servers, the history of events recorded by security devices and software, the communication history on the network, and the transmission and reception history of e-mails (including the contents of e-mails). is there. Many of these logs are recorded as text information and managed individually for each output source of the logs. In the field of information security, collecting logs output from these various information sources and managing them centrally will help to preserve evidence and investigate the causes of incidents such as information leaks. The movement is progressing.

  The log has the following characteristics.

  Since the log is constantly generated, the amount thereof continues to increase over time. Moreover, when collecting for the above purposes, it is necessary to keep for a long period of several months to several years, and the amount becomes enormous. In addition, the log output contents differ depending on the output source, and there are various formats. Many of the formats include date and time information, and there are many differences in the degree of freedom, but the formats are often fixed. However, the format is individually determined by the log information source, and there is no common format.

  Therefore, in a conventional electronic document search apparatus, when searching for attribute information included in a document, an attribute value (attribute value in advance) from the document is referred to as “attribute” below. It is common to use a relational database management system or the like that is extracted and recorded in a dedicated file for management.

  However, because of the variety of formats described above, when the number of types of logs to be saved is increased, the attribute extraction method uses attribute information as long as the attribute extraction method is not defined. There was a problem that it could not be extracted and stored. Also, when adding the type of attribute that you want to extract, if the log that keeps increasing over time is stored for a long time, the amount will be huge, so extract the attribute from all the saved logs There was a problem that it was difficult to fix.

For such log storage and retrieval, a log-dedicated database as shown in Non-Patent Document 1 is effective. This log-dedicated database is designed based on the following policy.
(1) Regardless of the log format, the collected logs are stored in the storage medium in the same format.
(2) Search according to search conditions that are conscious of the log format.

By doing so, there are the following effects.
(1) Since no attribute extraction is performed from the log, it is possible to save any type of log.
(2) By specifying the search conditions with consideration of the log format using regular expressions, it is possible to flexibly specify the attributes to be searched.

  Here, the regular expression is a kind of notation of a search condition by a character string. In regular expressions, it is possible to express search conditions in a more general manner by allowing selection from a plurality of characters and character strings, and specifying repetition of them as part of a search character string.

In the above-mentioned log-dedicated database, there is a problem that the regular expression becomes complicated depending on the search condition and is difficult to describe. For example, a regular expression for searching a date included in the range of “2006/7/1 to 2006/10/15” from the log is:
“[^ 0-9] (2006 / ([7-8] / ([1-9] | [1-2] [0-9] | 3 [0-1]) | 9 / ([1-9 ] | [1-2] [0-9] | 30) | 10 / ([1-9] | 1 [0-5])) [^ 0-9] "
And so on. Such regular expressions are difficult to describe for those who have little knowledge of regular expressions, and at the same time, those who are familiar with regular expressions need trial and error to write accurately.

Similarly, there are some cases where it is difficult to describe the regular expression depending on the search condition in consideration of the log format. As an example of such a case, there is a search condition in a case where a search for a specific field separated by a comma “,” is performed on a log in a CSV (Comma / Separated / Values) format. For example, a search condition that “a character string“ file ”is included in the field surrounded by the third and fourth commas from the top of the line”
“(^ | ¥ n) ([^,] *,) {3} [^,] * file”
Can be described as follows. Even though it is a CSV format, some fields are surrounded by double quotes “” ”, so if you try to cover various patterns, regular expressions will become more complicated and it will be difficult to describe search conditions. Become. Further, a regular expression for searching for a date included in a specific field as described above in a specific field becomes complicated.

  Text search using regular expressions is widely used, including the grep command of the UNIX (registered trademark) OS (operating system) and the script language Perl. The problems as described above are not problems that are limited to log searches, but are common to processing systems that perform searches using these regular expressions. Further, as in the prior art, there is still a problem that exists in a method of converting a keyword into a regular expression so that the keyword can be searched with different notation or similar notation.

  An object of the present invention is to efficiently generate a regular expression for searching a certain range of attribute values.

A regular expression generation device according to one aspect of the present invention is provided.
An attribute range condition input unit for inputting attribute range condition data indicating a lower limit value, an upper limit value and a format of the attribute value from an input device;
Based on the format indicated by the attribute range condition data input by the attribute range condition input unit, the attribute value is equal to or greater than the lower limit value indicated by the attribute range condition data input by the attribute range condition input unit, and the least significant digit A first value in which at least one digit is the maximum value of the digit and an attribute value equal to or lower than the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit, and at least 1 from the lowest digit A computing unit that computes the second value, the digit of which is the minimum value of the digit, by the processing device;
Attribute value storage that stores the lower limit value and the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit, and the first value and the second value calculated by the calculation unit in a storage device And
Lower region data representing the attribute value from the lower limit value to the first value stored by the attribute value storage unit in a regular expression, and the attribute value from the second value to the upper limit value stored by the attribute value storage unit If the attribute value exists between the first value and the second value stored in the attribute value storage unit, the upper region data representing the regular expression in the regular expression is generated by the processing device. A regular expression generating unit that generates intermediate region data representing a value in a regular expression by a processing device;
The lower region data, the upper region data, and the middle region data generated by the regular expression generation unit are combined by a processing device, and the attribute values from the lower limit value to the upper limit value stored by the attribute value storage unit are normalized. And a regular expression combining unit that generates regular expression data expressed in terms of expressions.

  According to one aspect of the present invention, in the regular expression generation device, the arithmetic unit is an attribute value that is equal to or greater than the lower limit value based on the format of the attribute value, and at least one digit from the least significant digit is the maximum value of the digit. A certain first value and an attribute value equal to or lower than the upper limit value, and at least one digit from the least significant digit is calculated as a second value that is the minimum value of the digit, and the regular expression generator generates the first value from the lower limit value. Generating lower region data that represents an attribute value up to the value in a regular expression and upper region data representing an attribute value from the second value to the upper limit value in a regular expression, and the first value and the second value When there is an attribute value in between, the middle region data that represents the attribute value in regular expression is generated, and the regular expression combining unit combines the lower region data, the upper region data, and the middle region data, Efficiently generate regular expressions for searching a range of attribute values It becomes possible.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings.

In the following description, a regular expression is assumed assuming that it is generally used unless otherwise specified. In general regular expressions, for example,
(1) <ordinary character> collates ordinary characters.
(2) \ <special character> collates special characters (“|”, “?”, “*”, “+”, “¥”, “^”, etc.).
(3) [abc. . . ] Is the character abc. . . Match any single character in it.
(4) [az] collates an arbitrary character whose character code is in the range from a to z.
(5) [^ abc. . . ] Is the character abc. . . Match any single character other than.
(6) [^ a-z] collates an arbitrary character whose character code is not in the range from a to z.
(7) ^ matches the beginning of a line.
(8) $ matches the end of the line.
(9) <Regular expression>? Matches what <regular expression> appears 0 times or once.
(10) <Regular expression> * matches what <Regular expression> is repeated 0 times or any number of times.
(11) <Regular expression> + matches those in which <Regular expression> is repeated one or more times.
(12) <Regular expression> {n} is a collation of <regular expression> repeated n times.
(13) <Regular expression> {n,} matches those in which <regular expression> is repeated n times or more.
(14) <Regular expression> {, m} matches those in which <regular expression> is repeated 0 to m times.
(15) <Regular expression> {n, m} matches those in which <regular expression> is repeated n times or more and m times or less.
(16) <Regular expression 1> | <Regular expression 2> matches <Regular expression 1> or <Regular expression 2>.
(17) <Regular expression 1><Regular expression 2> matches those whose first half is <regular expression 1> and the second half is <regular expression 2>.

  In the following, as a general rule, regular expressions are shown in the form of “<regular expression>” enclosed in double quotations.

Embodiment 1 FIG.
FIG. 1 is a block diagram showing a configuration of a regular expression generation device 100 according to the present embodiment.

  In FIG. 1, the regular expression generation apparatus 100 includes an attribute range condition input unit 101, a calculation unit 102, an attribute value storage unit 103, a regular expression generation unit 104, a regular expression combination unit 105, and an output unit 106. Further, the regular expression generation device 100 includes hardware devices such as a storage device 151, a processing device 152, an input device 153, and an output device 154 (or these hardware devices are connected to the regular expression generation device 100). The hardware device is used by each unit of the regular expression generation device 100. For example, the processing device 152 is used to perform calculation, processing, reading, writing, and the like of data and information in each unit of the regular expression generation device 100. The storage device 151 is used to store the data and information. The input device 153 is used to input the data and information, and the output device 154 is used to output the data and information.

  The attribute range condition input unit 101 inputs attribute range condition data from the input device 153. The attribute range condition data is attribute range condition data indicating a lower limit value, an upper limit value, and a format of the attribute value. For example, when the attribute value is an integer value ranging from 123 to 7654, the lower limit value is 123, the upper limit value is 7654, and the format is an integer value type of 3 to 4 digits (maximum 4 digits). In this example, the attribute range condition input unit 101 inputs attribute range condition data indicating that the attribute value is a numerical value as the attribute value format. For example, if the attribute value is a character string, The attribute range condition input unit 101 inputs attribute range condition data indicating that the attribute value is a character string as the format of the attribute value.

  The computing unit 102 computes the first value and the second value by the processing device 152 based on the format indicated by the attribute range condition data input by the attribute range condition input unit 101. The first value is an attribute value that is equal to or greater than the lower limit value indicated by the attribute range condition data input by the attribute range condition input unit 101, and at least one digit from the least significant digit is the maximum value of the digit. is there. As in the above example, when the lower limit value is 123, the first value is 129, 199, 999, 6999, 7599, 7649, and the like. On the other hand, the second value is an attribute value equal to or lower than the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit 101, and at least one digit from the least significant digit is the minimum value of the digit Value. When the upper limit value is 7654 as in the above example, the second value is 130, 200, 1000, 7000, 7600, 7650, or the like.

  In particular, in the present embodiment, the calculation unit 102 has, as the first value, the same number of digits as the lower limit value indicated by the attribute range condition data input by the attribute range condition input unit 101 and at least a digit other than the most significant digit. Calculate the attribute value that is the maximum value of each digit. As in the above example, when the lower limit value is 123, the first value is 199, 999, or the like. In addition, the calculation unit 102 has the same value as the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit 101 as the second value, and at least the digits other than the most significant digit are the minimum value of each digit. The attribute value is calculated. As in the above example, when the upper limit value is 7654, the second value is 1000, 7000, or the like.

  Furthermore, in the present embodiment, the calculation unit 102 uses the same value as the first value and the lower-order value indicated by the attribute range condition data input by the attribute range condition input unit 101 is the same as the most significant digit. Calculates the attribute value that is the maximum value of digits. As in the above example, when the lower limit value is 123, the first value is 199. In addition, the calculation unit 102 uses the same value as the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit 101 as the second value and the other digit as the minimum value of each digit. Calculate an attribute value. As in the above example, when the upper limit value is 7654, the second value is 7000.

  The attribute value storage unit 103 stores the lower limit value and the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit 101, and the first value and the second value calculated by the calculation unit 102. Store in device 151.

The regular expression generation unit 104 uses lower region data (hereinafter simply referred to as “regular expression” or “lower region normalization”) representing the attribute values from the lower limit value to the first value stored in the attribute value storage unit 103 in a regular expression. And the upper region data representing the attribute values from the second value to the upper limit value stored in the attribute value storage unit 103 in regular expressions (hereinafter simply referred to as “regular expressions” or “upper ranks”). The processing device 152 generates a “regular expression of a region” in some cases. As in the above example, when the lower limit value is 123, the upper limit value is 7654, the first value is 199, and the second value is 7000, the lower area data is
“12 [3-9] | 1 [3-9] [0-9]” (regular expression of 123-199),
The upper area data is
“7 [0-5] [0-9] [0-9] | 76 [0-4] [0-9] | 765 [0-4]” (regular expression of 7000-7654)
And so on. In addition, when there is an attribute value between the first value and the second value stored in the attribute value storage unit 103, the regular expression generation unit 104 represents the intermediate value that represents the attribute value with a regular expression. Region data (hereinafter, simply referred to as “regular expression” or “regular expression of middle region” in some cases) is generated by the processing device 152. As in the above example, when the first value is 199 and the second value is 7000, the middle region data is
“[2-9] [0-9] [0-9] | [1-6] [0-9] [0-9] [0-9]” (regular expression of 200 to 6999)
And so on.

The regular expression combining unit 105 combines the lower region data, the upper region data, and the middle region data generated by the regular expression generation unit 104 by the processing device 152, and uses the lower limit value stored by the attribute value storage unit 103. Regular expression data (hereinafter, simply referred to as “regular expression” or “regular expression of attribute value” in some cases) that represents the attribute value up to the upper limit value is generated. As in the above example, the lower area data is “12 [3-9] | 1 [3-9] [0-9]”, and the upper area data is “7 [0-5] [0-9] [0 −9] | 76 [0-4] [0-9] | 765 [0-4] ”, and the middle region data is“ [2-9] [0-9] [0-9] | [1-6 ] [0-9] [0-9] [0-9] ", the regular expression data is
“(12 [3-9] | 1 [3-9] [0-9]) | ([2-9] [0-9] [0-9] | [1-6] [0-9] [ 0-9] [0-9]) | (7 [0-5] [0-9] [0-9] | 76 [0-4] [0-9] | 765 [0-4]) "
And so on.

  The output unit 106 outputs the regular expression data generated by the regular expression combination unit 105 to the output device 154.

  As described above, in the present embodiment, the regular expression generation device 100 receives as input the attribute range condition that specifies the lower limit value and the upper limit value of the values included in the attribute value range as the search condition, and uses the attribute range condition as the search range. Implement a search condition generation method that converts a character string that represents an attribute value included in the range specified in the condition into a regular expression for matching, or a search condition generation program for executing this method on a computer Is.

  In the search condition generation method, for example, an attribute range condition for selecting a numerical range is converted into a regular expression. Also, for example, an attribute range condition for selecting a character string range is converted into a regular expression.

In the search condition generation method, for example, an attribute range condition including an attribute lower limit value, upper limit value, and attribute format (including attribute data type)
Attribute range condition = (0,255,% 3d)
And enter. Here, as an example
Lower limit of attribute = 0
Upper limit of attribute = 255
Attribute format (number of digits and data type) = "(maximum) 3-digit integer value"
It is said. In this example, the notation of format specification of a formatted output function such as “printf” in C language is used to represent the format of the attribute. It doesn't have to be law. Moreover, if the same conditions can be input, the input method is not ask | required.

When the above attribute range condition is input, a regular expression for collating a character string representing an attribute value included in the range from the lower limit value to the upper limit value by the regular expression generation device 100,
Regular expression = “[^ 0-9] ([0-9] | [1-9] [0-9] | 1 [0-9] [0-9] | 2 [0-4] [0-9 ] [25 [0-5]) [^ 0-9] "
Etc. are output. It should be noted that it is not necessary that all the items constituting the attribute range condition are complete. For example, if there is no lower limit value, the lower limit value may be handled as the minimum value that the attribute value can take (in the above example, the lower limit value = 0). For example, if there is no upper limit value, the upper limit value may be treated as the maximum value that can be taken by the attribute value (in the above example, the upper limit value is ∞). Also, for example, if the attribute format is not shown to be an integer value, the attribute data type may be assumed to be a character string, and the lower limit value and the upper limit value are integer values. It may be estimated that the data type of is an integer value.

  As described below, the search condition generation method may be realized as a program that runs on a computer such as a PC (personal computer) or a PC server, or a hardware having a functional unit that implements the method. It may be implemented as wear.

  FIG. 2 is a diagram illustrating an example of the appearance of the regular expression generation device 100.

  In FIG. 2, a regular expression generating apparatus 100 includes a system unit 910, a display device 901 having a display screen of a CRT (Cathode / Ray / Tube) or LCD (Liquid Crystal Display), a keyboard 902 (K / B), a mouse 903, and an FDD 904. (Flexible / Disk / Drive), CDD905 (Compact / Disc / Drive), printer device 906, and other hardware resources, which are connected by cables and signal lines. The system unit 910 is a computer and is connected to the Internet 940 via a LAN 942 (local area network) and a gateway 941.

  FIG. 3 is a diagram illustrating an example of hardware resources of the regular expression generation device 100.

  In FIG. 3, the regular expression generating apparatus 100 includes a CPU 911 (Central Processing Unit) (also referred to as “arithmetic unit”, “microprocessor”, “microcomputer”, “processor”) that executes a program. The CPU 911 is an example of the processing device 152. The CPU 911 includes a ROM 913 (Read / Only / Memory), a RAM 914 (Random / Access / Memory), a communication board 915, a display device 901, a keyboard 902, a mouse 903, an FDD904, a CDD905, a printer device 906, and a magnetic disk. It is connected to the device 920 and controls these hardware devices. Instead of the magnetic disk device 920, a storage medium such as an optical disk device or a memory card reader / writer may be used.

  The RAM 914 is an example of a volatile memory. The storage media of the ROM 913, the FDD 904, the CDD 905, and the magnetic disk device 920 are an example of a nonvolatile memory. These are examples of the storage device 151. The communication board 915, the keyboard 902, the mouse 903, the FDD 904, the CDD 905, and the like are examples of the input device 153. The communication board 915, the display device 901, the printer device 906, and the like are examples of the output device 154.

  The communication board 915 is connected to the LAN 942 or the like. The communication board 915 is not limited to the LAN 942, but includes the Internet 940, or a WAN (wide area network) such as an IP-VPN (Internet, Protocol, Virtual, Private, Network), a wide area LAN, and an ATM (Asynchronous, Transfer, Mode) network. It may be connected to the When connected to the Internet 940 or WAN, the gateway 941 is not necessary.

  The magnetic disk device 920 stores an operating system 921, a window system 922, a program group 923, and a file group 924. The programs in the program group 923 are executed by the CPU 911, the operating system 921, and the window system 922. The program group 923 stores programs for executing functions described as “˜unit” and “˜means” in the description of the present embodiment. The program is read and executed by the CPU 911. The file group 924 includes data and information described as “˜data”, “˜information”, “˜ID (IDentifier)”, “˜flag”, “˜result” in the description of this embodiment. Signal values, variable values, and parameters are stored as items of “˜file”, “˜database”, and “˜table”. The “˜file”, “˜database”, and “˜table” are stored in a storage medium such as a disk or a memory. Data, information, signal values, variable values, and parameters stored in a storage medium such as a disk or memory are read out to the main memory or cache memory by the CPU 911 via a read / write circuit, and extracted, searched, referenced, compared, and calculated. Used for processing (operation) of the CPU 911 such as calculation / control / output / printing / display. Data, information, signal values, variable values, and parameters are temporarily stored in the main memory, cache memory, and buffer memory during processing of the CPU 911 such as extraction, search, reference, comparison, calculation, control, output, printing, and display. Is remembered.

  In the block diagrams and flowcharts described in the description of this embodiment, the arrows indicate mainly input and output of data and signals. Data and signals are stored in a memory such as a RAM 914, a flexible disk (FD) of the FDD 904, and a CDD 905. Recording is performed on a recording medium such as a compact disk (CD), a magnetic disk of the magnetic disk device 920, other optical disks, a mini disk (MD), and a DVD (Digital Versatile Disc). Data and signals are transmitted by a bus 912, a signal line, a cable, and other transmission media.

  In the description of the present embodiment, what is described as “to part” and “to means” may be “to circuit”, “to device”, and “to device”, and “to step”. , “˜step”, “˜procedure”, and “˜treatment”. That is, what is described as “˜unit” and “˜means” may be realized by firmware stored in the ROM 913. Alternatively, it may be realized only by software, or only by hardware such as an element, a device, a board, and wiring, or a combination of software and hardware, and further by a combination of firmware. Firmware and software are stored as programs in a recording medium such as a magnetic disk, flexible disk, optical disk, compact disk, minidisk, or DVD. This program is read by the CPU 911 and executed by the CPU 911. In other words, the program causes the computer to function as “to part” and “to means” described in the description of the present embodiment. Alternatively, the procedure or method of “˜unit” and “˜means” described in the description of the present embodiment is executed by a computer.

  In the following, in order to make the description more specific, it is assumed that the regular expression generation device 100 is realized by the computer and hardware resources illustrated in FIGS. 2 and 3.

  FIG. 4 is a flowchart showing a regular expression generation method according to this embodiment. The flow shown in the flowchart of FIG. 4 corresponds to a processing procedure of a program (regular expression generation program) executed on a computer that implements the regular expression generation apparatus 100. In this processing procedure, the regular expression generation program causes the computer to execute the following processes.

  When the user of the regular expression generating apparatus 100 specifies attribute range condition data with the keyboard 902 or the mouse 903, the attribute range condition input unit 101 inputs the attribute range condition data from the keyboard 902 or the mouse 903 (step S101: attribute). Range condition input processing).

  The computing unit 102 computes the first value and the second value by the CPU 911 based on the format indicated by the attribute range condition data input by the attribute range condition input unit 101 (part of step S102: computation processing). ). The attribute value storage unit 103 stores the lower limit value and the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit 101, the first value and the second value calculated by the calculation unit 102, in the RAM 914. (Part of step S102: attribute value storage process).

  In step S102, the computing unit 102 computes the first value and the second value to obtain the attribute values included in the range from the lower limit value to the upper limit value of the attribute range condition as lower, middle, upper Are divided into three areas. Of the three regions, the middle region is a range of values that can semi-fixedly convert attribute values included in the range into regular expressions. The lower region indicates a range of values from the lower limit value of the attribute range condition (that is, the lower limit value of the attribute value) to one level lower than the lower limit value of the middle region (that is, the first value). The upper region refers to a range of values from the upper limit value of the middle region (that is, the second value) to the upper limit value of the attribute range condition (that is, the upper limit value of the attribute value). A method of calculating each region will be described later with a specific example.

  When there is an attribute value between the first value and the second value stored in the attribute value storage unit 103, the regular expression generation unit 104 represents intermediate region data that represents the attribute value with a regular expression. Is generated by the CPU 911 (step S103: part of the regular expression generation process). If there is no attribute value between the first value and the second value, the middle region data is not generated. The regular expression generation unit 104 generates lower region data representing the attribute values from the lower limit value to the first value stored in the attribute value storage unit 103 in a regular expression by the CPU 911 (step S104: one of the regular expression generation processes). Part). The regular expression generation unit 104 generates upper region data representing the attribute values from the second value to the upper limit value stored in the attribute value storage unit 103 in regular expressions by the CPU 911 (step S105: one of the regular expression generation processes). Part).

  In steps S103, S104, and S105, the regular expression generation unit 104 generates a corresponding regular expression for each of the middle, lower, and upper three regions. Since the processes of steps S103, S104, and S105 do not depend on the order, they may be executed in any order.

  The regular expression combining unit 105 combines the lower region data, the upper region data, and the middle region data generated by the regular expression generation unit 104 by the CPU 911 (when the middle region data is not generated in step S103). Will combine only the lower area data and the upper area data), and generates regular expression data representing the attribute values from the lower limit value to the upper limit value stored by the attribute value storage unit 103 in regular expressions (step S106). : Regular expression combination processing).

  The output unit 106 outputs the regular expression data generated by the regular expression combining unit 105 to the screen of the display device 901 (step S107: output processing). A user of the regular expression generation device 100 can easily search for a log or the like by inputting the regular expression data as a search condition into the log-dedicated database or the like.

  Hereinafter, the flow of processing for generating a regular expression will be described with an example. What is described here is a character string expressing a value X (attribute value X from lower limit value A to upper limit value B) that satisfies A ≦ X ≦ B with respect to lower limit value A and upper limit value B of the attribute range condition. This is a flow of processing for generating a regular expression for matching.

First, here, it is expressed as follows only when the lower limit value of the attribute value is equal to the number of digits of the upper limit value.
Lower limit A: A _n A _n-1 . . . A ₂ A ₁
Upper limit B: B _n B _n−1 . . . B ₂ B ₁
Here, the larger the subscript, the higher the digit.
Each of the attribute elements A _i and B _i (1 ≦ i ≦ n) constituting the attribute value is one number or character, and the value ranges are v ₁ ≦ A _i and B _i ≦ v _q . However, it is assumed that only the most significant digit is v ₂ ≦ A _n and B _n ≦ v _q . Here, for simplicity, it is assumed that the value ranges of all the digits except the most significant digit are the same. Further, (v _j ) _k represents that “the value of the k-th digit is v _j ”. Furthermore, the magnitude relationship between the attribute values is determined based on the following criteria.
A _n = B _n , A _n−1 = B _n−1,. . . , A _{k + 1} = B _{k + 1} (1 ≦ k ≦ n), B> A if B _k > A _k
A _i +1 is described to increase the value of A _i by 1. When A _i = v _j , A _i + 1 = v _{j + 1} . However, when A _i = v _q , A _i + 1 = v ₁ and further A _{i + 1} +1. Similarly, A _i −1 is described, and the value of A _i is decreased by 1. When A _i = v _j , A _i −1 = v _j−1 . However, when A _i = v ₁ , A _i −1 = v _q, and further A _{i + 1} −1. Increasing the attribute value A by 1 is described as A + 1, and means A ₁ +1. Similarly, reducing the attribute value A by 1 is described as A-1, and means A ₁ -1.

  A typical attribute value having such characteristics is an integer value (absolute value).

Here, when the lower limit value A and the upper limit value B are equal, it is only necessary to output the following as a regular expression without executing step S102.
Regular expression: “A _n A _n−1 ... A ₂ A ₁ ”

  Hereinafter, a case where the lower limit value and the upper limit value are not equal will be described.

  In step S102, the calculation unit 102 divides the attribute value into three regions, a lower region, a middle region, and an upper region. Among them, first, the middle region is obtained. In the middle region, the value range can be obtained as follows in accordance with the processing flow shown in FIG. In FIG. 5, the lower limit value (that is, a value that is 1 larger than the first value) in the middle region is L, and the upper limit value is U (that is, a value that is 1 smaller than the second value).

In FIG. 5, the arithmetic unit 102 compares the values of the same digit of the lower limit value A and the upper limit value B of the attribute value in order from the most significant digit (nth digit) (step S201) (step S202). . When the value of A and B is the same for a certain digit (i-th digit), the arithmetic unit 102 also sets the same digit (L _i , U _i ) of L and U to the value (A _i ) (step S203). ), A and B are compared for the next digit (step S204). When the compared digits have different values between A and B, the arithmetic unit 102 sets the same digit (L _i ) of L to a value (A _i +1) larger than the value of A and the same digit of U (U _i ) is set to a value (B _i −1) that is one smaller than the value of B (step S205). For each digit from the next digit to the least significant digit (steps S206 and S207), L is set to the minimum value (v ₁ ) of that digit, and U is set to the maximum value (v _q ) of that digit. (Step S208). As a result, L and U are obtained as follows. At this time, the attribute value storage unit 103 stores L and U in the RAM 914.
Middle region (lower limit L): _An . . . A _{k + 1} (A _k +1) (v ₁ ) _k−1 . . . (V ₁ ) ₁
Middle region (upper limit U): B _n . . . B _{k + 1} (B _k −1) (v _q ) _k−1 . . . (V _q ) ₁
However, A _n = B _n , A _n−1 = B _n−1,. . . , A _{k + 1} = B _{k + 1} (1 ≦ k ≦ n)

Next, a value obtained by reducing the lower limit value of the middle region by 1 is set as the upper limit value (that is, the first value) of the lower region, and the lower region is obtained as follows. At this time, the attribute value storage unit 103 stores the lower limit value A and the first value (L−1) of the attribute value in the RAM 914.
Lower region (lower limit A): An _{n n-1} . . . A ₂ A ₁
Lower region (upper limit value): _An . . . A _k (v _q ) _k−1 . . . (V _q ) ₁

Further, the value obtained by increasing the upper limit value of the middle region by 1 is set as the lower limit value (ie, the second value) of the upper region, and the upper region is obtained as follows. At this time, the attribute value storage unit 103 stores the second value (U + 1) and the upper limit value B of the attribute value in the RAM 914.
Upper region (lower limit): B _n . . . B _k (v ₁ ) _k−1 . . . (V ₁ ) ₁
Upper region (upper limit B): B _n B _n−1 . . . B ₂ B ₁

In step S103, the regular expression generation unit 104 generates a regular expression for the middle region. The regular expression corresponding to the middle region depends only on the number k of non-common parts of the middle region and the values of A _k and B _k and can be generated as follows. Since the values from the (k + 1) th digit to the nth digit can be processed as common parts in step S106, they are omitted here.
Regular expression of middle region: “[(A _k +1) − (B _k −1)] [v ₁ −v _q ] {k−1}”
Here, when B _k −A _k = 1, (A _k +1)> (B _k −1) is satisfied. In this case, the regular expression of the middle region is not output. Other than that, it can process similarly.

In the regular expression, if “k−1 = 1”, “{1}” at the end may be omitted. If k−1 = 0, the end “[v ₁ −v _q ] {0}” may be omitted. Also in the following description, “[v _i −v _j ] {1}” in the regular expression can be described as “[v _i −v _j ]”, and “[v _i −v _j ] {0}”. Can be omitted. _{Also, "[v i -v i]} " is simply assumed to be described as _{"v i".}

FIG. 6 shows the flow of regular expression generation processing corresponding to the following attribute value ranges.
Lower limit: A _k A _k−1 . . . A ₁
Upper limit value: (v _j ) _k (v _q ) _k−1 . . . (V _q ) ₁ (where v _j ≧ A _k )

In the processing flow of FIG. 6, the regular expression generation unit 104 advances the processing from the lowest digit to the higher digit. The input here is the lower limit value A _k . . . A ₁ , upper limit value (v _j ) _k (v _q ) _k−1 . . . (V _q ) ₁ and the number of digits k. In step S301, the regular expression generation unit 104 sets “A _k ... A ₂ [A ₁ −v _q ]” as an initial value in the regular expression storage area (E) in the RAM 914. In step S302 and subsequent steps, the processes in steps S304 to S306 are repeated from the second least significant digit to the (k-1) th digit. If it is determined in step S303 that the processing target is lower than the k-th digit (YES), the process is divided in step S304 depending on whether or not the value of the digit is v _q . In the case of v _q (YES), the regular expression generation unit 104 shifts to the next digit process without outputting anything. When it is not v _q (NO), the regular expression generation unit 104 adds “| A _k ... A _{i + 1} [(A _i +1) −v _q ] [v at the end of the regular expression output area (E). ₁ −v _q ] {i−1} ”is added, and the processing shifts to the next digit. In step S303, if the processing up to the (k−1) th digit has been completed (NO), the process proceeds to step S307. In step S307, when A _k and v _j are equal (YES), the regular expression generation unit 104 ends the process without doing anything. When A _k and v _j are not equal (NO), the regular expression generation unit 104 proceeds to step S308, and “| [(A _k +1) −v _j ] [v ₁ is added to the end of the regular expression storage area (E). −v _q ] {k−1} ”is added, and the process ends. What is stored in the regular expression storage area (E) when the processing is completed is a regular expression corresponding to the above range.

N, _A n _{= B} flows regular expression generation processing of the lower region, in FIG. 6 at step S104. . . , A _{k + 1} = B _{k + 1} (1 ≦ k ≦ n) corresponding to the case where the lower limit value and the upper limit value are set as follows for k.
Lower limit: A _k A _k−1 . . . A ₁
Upper limit value: A _k (v _q ) _k−1 . . . (V _q ) ₁
In step S104, the regular expression of the lower region generated by the regular expression generation unit 104 is as follows. Since the values from the (k + 1) th digit to the nth digit can be processed as common parts in step S106, they are omitted here.
Regular expression of subregion: “A _k ... A ₂ [A ₁ −v _q ] | A _k ... A ₃ [(A ₂ +1) −v _q ] [v ₁ −v _q ] | | A _k [(A _k−1 +1) −v _q ] [v ₁ −v _q ] {k−2} ”

FIG. 7 shows the flow of regular expression generation processing corresponding to the following attribute value ranges.
Lower limit value: (v _j ) _k (v ₁ ) _k−1 . . . (V ₁ ) ₁ (where v _j ≦ B _k )
Upper limit value: B _k B _k−1 . . . B ₁

In the processing flow of FIG. 7, the regular expression generation unit 104 advances the processing from the lowest digit to the higher digit, similarly to the processing flow of FIG. The input here is the lower limit value (v _j ) _k (v ₁ ) _k−1 . . . (V ₁ ) ₁ , upper limit value B _k . . . B ₁ and the number of digits k. In step S401, the regular expression generation unit 104 sets “B _k ... B ₂ [v ₁ −B ₁ ]” as an initial value in the regular expression storage area (E) in the RAM 914. In step S402 and subsequent steps, the processes in steps S404 to S406 are repeated from the second least significant digit to the k-1th digit. In step S403, if the processing of the target is lower than the k-th digit (YES), in step S404, isolate the processing depending on whether the value of that digit is _{v 1} or. In the case of v ₁ (YES), the regular expression generation unit 104 shifts to the next digit process without outputting anything. When it is not v ₁ (NO), the regular expression generation unit 104 adds “| B _k ... B _{i + 1} [v ₁ − (B _i −1)] [[at the end of the regular expression output area (E)”. v ₁ −v _q ] {i−1} ”is added, and the process proceeds to the next digit processing. In step S403, if the processing up to the (k-1) th digit has been completed (NO), the process proceeds to step S407. In step S407, when B _k and v _j are equal (YES), the regular expression generation unit 104 ends the process without doing anything. If B _k and v _j are not equal (NO), the regular expression generation unit 104 proceeds to step S408, and “| [v _j − (B _k −1)] [v at the end of the regular expression storage area (E). ₁ −v _q ] {k−1} ”is added, and the process ends. What is stored in the regular expression storage area (E) when the processing is completed is a regular expression corresponding to the above range.

The flow of regular expression generation processing for the upper region in step S105 is shown in FIG. 7 as A _n = B _n,. . . , A _{k + 1} = B _{k + 1} (1 ≦ k ≦ n) corresponding to the case where the lower limit value and the upper limit value are set as follows for k.
Lower limit value: B _k (v ₁ ) _k−1 . . . (V ₁ ) ₁
Upper limit value: B _k B _k−1 . . . B ₁
In step S105, the regular expression of the upper region generated by the regular expression generation unit 104 is as follows. Since the values from the (k + 1) th digit to the nth digit can be processed as common parts in step S106, they are omitted here.
Regular expression of the upper _{area: "B k ... B 2 [} v 1 -B 1] | B k ... B 3 [v 1 - (B 2 -1)] [v 1 -v q] | .. . | B _k [v ₁ − (B _k−1 −1)] [v ₁ −v _q ] {k−2} ”

  The processing for dividing the attribute value range into the lower, middle, and upper regions and generating the corresponding regular expressions has been described above. Next, the regular expression generated by the regular expression combining unit 105 by combining the generated regular expressions in step S106 will be described.

The regular expression combining unit 105 combines the lower, middle, and upper region regular expressions, and adds the common part (from the k + 1st digit to the nth digit) omitted in steps S103 to S105 to the combined regular expression. To do. As a result, the regular expression finally generated is in the following format.
“A _n ... A _{k + 1} (<Regular expression in lower region> || <Regular expression in middle region> | <Regular expression in upper region>)”
In addition, the regular expression generated when there is no middle region has the following format.
“A _n ... A _{k + 1} (<Regular expression in lower region> | <Regular expression in upper region>)”

In the regular expression, not only the value X satisfying A ≦ X ≦ B but also a character string representing the values v _i X, Xv _j , and v _i Xv _j is hit. Therefore, to avoid such a hit, it is preferable to add an exclusion character designation “[^ v ₁ −v _q ]” before and after the generated regular expression.

Hereinafter, a case where the upper limit value and the lower limit value of the attribute range condition are different will be described. That is, the following cases.
Lower limit A: A _n A _n-1 . . . A ₂ A ₁
Upper limit B: B _m B _m−1 . . . B ₂ B ₁ (m> n)
When the number of digits of the attribute value is different, B> A if m> n. Or, from n + 1 digit of the lower limit A to the m-th digit it can also be considered that there is v ₁ as an implicit value.

First, when mn = 1, the lower, middle, and upper regions can be obtained as follows.
Subregion: A _n A _n-1 . . . _{A 2 A 1 ~ (v q} ) n (v q) n-1. . . (V _q ) ₂ (v _q ) ₁
Middle region: none Upper region: (v ₁ ) _m (v ₁ ) _m−1 . . . _{(V 1) 2 (v 1} ) 1 ~B m B m-1. . . B ₂ B ₁
The subsequent processing flow is the same as the processing flow shown in FIG. 4, FIG. 6, and FIG.

Alternatively, even in the case of mn = 1, the middle region may be obtained as follows according to the processing flow of FIG.
Middle region: (A _n +1) (v ₁ ) _n−1 . . . (V ₁ ) ₂ (v ₁ ) ₁ to (B _m −1) (v _q ) _m−1 . . . (V _q ) ₂ (v _q ) ₁
At this time, the lower area and the upper area are as follows.
Subregion: A _n A _n-1 . . . A ₂ A _{1 to An} (v _q ) _n-1 . . . (V _q ) ₂ (v _q ) ₁
Upper region: B _m (v ₁ ) _m−1 . . . _{(V 1) 2 (v 1} ) 1 ~B m B m-1. . . B ₂ B ₁
And the regular expression of the middle region is as follows.
Regular expression of middle region: “[(A _n +1) −v _q ] [v ₁ −v _q ] {n−1} | [v ₂ − (B _m −1)] [v ₁ −v _q ] { m−1} ”

In the case of mn> 2, the lower, middle and upper areas can be processed in the same manner as follows.
Subregion: A _n A _n-1 . . . _{A 2 A 1 ~ (v q} ) n (v q) n-1. . . (V _q ) ₂ (v _q ) ₁
Middle region: (v ₂ ) _{n + 1} (v ₁ ) _n . . . (V ₁ ) ₂ (v ₁ ) ₁ to (v _q ) _m-1 (v _q ) _m-2 . . . (V _q ) ₂ (v _q ) ₁
Upper region: (v ₂ ) _m (v ₁ ) _m−1 . . . _{(V 1) 2 (v 1} ) 1 ~B m B m-1. . . B ₂ B ₁
And the regular expression of the middle region is as follows.
Regular expression of middle region: “[v ₂ −v _q ] [v ₁ −v _q ] {n, m−2}”

A specific example when the above method is applied to an integer value of 0 or more will be described. For decimal numbers, v ₁ = 0 and v _q = 9.

(Example 1-1) Attribute range condition: 123-246
Lower region: 123-199
Middle region: 200-199 (regular expressions are not generated)
Upper region: 200-246
Regular expression: “(12 [3-9] | 1 [3-9] [0-9]) | (24 [0-6] | 2 [0-3] [0-9])”

(Example 1-2) Attribute range condition: 2345-7654
Lower region: 2345-2999
Middle region: 3000-6999
Upper area: 7000-7654
Regular expression: “(234 [5-9] | 23 [5-9] [0-9] | 2 [4-9] [0-9] {2}) | [3-6] [0-9] {3} | (765 [0-4] | 76 [0-4] [0-9] | 7 [0-5] [0-9] {2}) ”

(Example 1-3) Attribute range condition: 7531 to 18939
Lower region: 7531 to 9999
Middle region: 10000-17999
Upper region: 18000-18939
Regular expression: “(753 [1-9] | 75 [4-9] [0-9]) | 7 [6-9] [0-9] {2} | [89] [0-9] {3 }) | 1 [0-7] [0-9] {3} | (1893 [0-9] | 189 [0-2] [0-9] | 18 [0-8] [0-9] { 2}) ”
Or
Lower region: 7531-7999
Middle region: 8000-17999
Upper region: 18000-18939
Regular expression: “(753 [1-9] | 75 [4-9] [0-9]) | 7 [6-9] [0-9] {2}) | ([8-9] [0− 9] {3} | 1 [0-7] [0-9] {3}) | (1893 [0-9] | 189 [0-2] [0-9] | 18 [0-8] [0 -9] {2}) "

(Example 1-4) Attribute range condition: 304 to 765432
Lower area: 304 to 999
Middle region: 1000-99999
Upper area: 100,000 to 765432
Regular expression: “(30 [4-9] | 3 [1-9] [0-9] | [4-9] [0-9] {2}) | [1-9] [0-9] { 3, 4} | (76543 [0-2] | 7654 [0-2] [0-9] | 765 [0-3] [0-9] {2} | 76 [0-4] [0-9 ] {3} | 7 [0-5] [0-9] {4} | [1-6] [0-9] {5}) ”

In the case of a numerical value, a continuation of 0 may be allowed before the numerical value. In the attribute range condition, when the format designation “arbitrary number of zeros are continuous at the beginning of the numerical value” is made, in step S107 of FIG. Generate as follows.
Regular expression: “[^ 1-9] 0 * (<Regular expression in lower region> || <Regular expression in middle region> || <Regular expression in upper region>) [^ 0-9]”

In addition, in the attribute range condition, a format specification (“% 0td” described in the format specification of the C printf function) is “the total number of digits is t, and if there is a shortage, 0 is added at the beginning”. If it is made, the regular expression combining unit 105 can generate a regular expression as follows.
Regular expression: “[^ 1-9] 0 {t−m, 0} (0 {m−n} <regular expression in lower region> | <regular expression in middle region> | <regular expression in upper region>) [^ 0-9] "
Here, the regular expression of the middle region is as follows.
Regular expression of middle region: “0 {t−n−1} [1-9] [0-9] {n} | 0 {tn−2} [1-9] [0-9] {n + 1 } | ... | 0 {tm-1} [1-9] [0-9] {m} "

In the case of a negative integer, the regular expression generation unit 104 can generate a regular expression in the same manner for the absolute value, and then add a negative sign to the head of the regular expression. Further, when the range of the attribute value crosses 0, the process may be performed by dividing into a positive (0 or more) area and a negative (less than 0) area. For example,
Lower limit value A: -A _n A _n-1 . . . A ₂ A ₁
Upper limit B: B _m B _m−1 . . . B ₂ B ₁
If the attribute range condition is given,
Positive lower limit: 0
Positive upper limit: B _m B _m−1 . . . B ₂ B ₁
as well as,
Negative lower limit value: -A _n A _n-1 . . . A ₂ A ₁
Negative upper limit: -1
The regular expressions are individually generated as follows, and the regular expression combining unit 105 finally combines as follows.
Regular expression: “<regular expression in the range of 0 to B> | (− <regular expression in the range of absolute values of 1 to A>)”

  In the description so far, the case where both the lower limit value A and the upper limit value B of the attribute value are specified has been shown. Here, a case where the upper limit value B is not specified or a case where the upper limit value is specified as “infinity” will be described. When the maximum value B ′ exists as the attribute data type, the regular expression combining unit 105 may generate a regular expression from the lower limit value A to the upper limit value B ′. When there is no maximum value as the data type of the attribute, it is better to process as follows.

First, the regular expression combining unit 105 generates a regular expression for the maximum value of attribute values having the same number of digits as the lower limit value A. That is, a regular expression is generated for the following n-digit lower and upper limit values.
Lower limit value A: _An . . . A ₁
Upper limit B ′: (v _q ) _n . . . (V _q ) ₁
Then, the regular expression combining unit 105 adds a regular expression “[v ₂ −v _q ] [v ₁ −v _q ] {n,}” of the attribute value higher than the n-th digit. The generated regular expression is in the following format.
Regular expression: “<Regular expression in the range of A to B ′> | [v ₂ −v _q ] [v ₁ −v _q ] {n,}”

A case where the lower limit value A is not specified or a case where the lower limit value is specified as “infinitesimal” will be described. First, if there is a minimum value A ′ as an attribute data type, the regular expression combining unit 105 may generate a regular expression for the lower limit value A ′ and the upper limit value B. For example, the minimum value is 1 if the data type of the search target attribute is a positive integer, and the minimum value is 0 if it is a natural number. When a negative integer value is also included, the regular expression combining unit 105 may generate the following regular expression according to the procedure shown so far. That is, a numerical range of 0 to B and a negative numerical value of one digit or more are considered. In the following regular expression description example, zero or more repetitions are represented by “*” instead of “{0,}”.
Regular expression: "<Regular expression in the range of 0 to B> | (-[1-9] [0-9] *)"

There may be two or more value ranges for each digit of the attribute, such that there are full-width and half-width numbers in the numbers and uppercase and lowercase letters in the alphabet (alphabetic characters) (v ₁ ≦ A _i ≦ v _q , w ₁ ≦ A _i ≦ w _q ,. Even in such a case, the regular expression combining unit 105 can generate a corresponding regular expression only by slightly correcting the processing flow shown above. That is, when it is specified that the descriptions of two or more types of attribute values are not distinguished, they can be generated by describing them side by side using a selection “|” or a character class. An example is shown.
(1) When using selection Before modification: “v _i v _j [v _k −v _l ]”
After correction: “(v _i v _j [v _k −v _l ] | w _i w _j [w _k −w _l ] |...)”
(2) When using a character class Before modification: “v _i v _j [v _k −v _l ]”
After correction: “[v _i w _i ...] [V _j w _j ...] [V _k −v _l w _k −w _l .

In the case of numerical values, every three digits from the lower digit may be separated by a comma “,”. The description of the regular expression in that case is as follows. At this time, according to the processing flow shown above, the regular expression of the lower area and the upper area has a fixed number of digits. In the following example, only a partial regular expression surrounded by a regular expression selection symbol “|” is shown.
Before correction: “A _m A _m−1 ... A _{n + 1} [v ₁ −v _q ] {n}”
After the modification: “A _m A _m−1 ... A _{n−t + 4} , A _{n−t + 3} ... A _{n + 1} [v ₁ −v _q ] {t} (, [v ₁ −v _q ] {3}) {S} ”
Here, s is a quotient of n / 3, and t is a surplus of n / 3.
As described above, the regular expression combining unit 105 may insert a comma between the n−t + 3 × i digit and the n−t + 3 × i + 1 digit for the (n + 1) th digit (i is a natural number).

In the above example, the case of a decimal number is shown. However, if v ₁ = 0 and v _q = F, a hexadecimal number can be processed in the same manner. In addition, any attribute having the same format as the present embodiment can be processed in the same manner.

Furthermore, although the description has been made mainly using the example of the integer value so far, the value of each digit does not have to be a number, and may be a numerical value of one digit or more or a set of ordered words. For example, when the month of the date is used, the English name of the month (January, February, March, ..., December) or its abbreviation (Jan, Feb, Mar, ..., Dec) is used. There is also. In this case, the month may be regarded as one attribute element having 12 values. At this time, if v ₁ = “Jan”, v ₂ = “Feb”, v ₃ = “Mar”,..., V ₁₂ = “Dec”, processing is performed according to the procedure shown in this embodiment. be able to. Such a processing method is particularly effective when the attribute value has the format shown in the third embodiment to be described later.

  As described above, according to the regular expression generation device 100 according to the present embodiment, the lower limit value is determined from the attribute range condition that specifies the lower limit value, upper limit value, format, etc. of the attribute having characteristics such as an integer value. A regular expression for collating a character string representing an attribute value included in the range from to the upper limit value can be automatically generated. As a result, a regular expression for matching complicated attribute range conditions, which has been difficult to describe accurately in the past, can be easily obtained in a short time without requiring special knowledge or trial and error.

Embodiment 2. FIG.
In the present embodiment, differences from the first embodiment will be mainly described.

  As described in the first embodiment, there are various ways of specifying the data type and format of the integer value. For example, these formats such as presence / absence of sign, maximum number of digits, decimal number notation, integer value range, presence / absence of leading zeros, presence / absence of comma delimiters, type of characters to be written, etc. It is complicated to specify the attribute range condition in detail. Therefore, in the present embodiment, in the regular expression generation device 100, a preset attribute range condition is stored in the storage device 151 so that it can be selected and used.

  FIG. 8 is a block diagram showing a configuration of regular expression generation apparatus 100 according to the present embodiment.

  In FIG. 8, the regular expression generation apparatus 100 includes a condition storage unit 107 and an identifier input unit 108 in addition to the one shown in FIG. 1 described in the first embodiment.

  The condition storage unit 107 stores a plurality of attribute range condition data in the storage device 151 in advance. The condition storage unit 107 stores each attribute range condition data in the storage device 151 in association with a unique identifier.

  The identifier input unit 108 inputs an arbitrary identifier from the input device 153.

  The attribute range condition input unit 101 inputs the attribute range condition data stored in the condition storage unit 107 in association with the identifier input by the identifier input unit 108.

  FIG. 9 is a flowchart showing a regular expression generation method according to the present embodiment. The flow shown in the flowchart of FIG. 9 corresponds to a processing procedure of a program (regular expression generation program) executed on a computer that implements the regular expression generation apparatus 100. In this processing procedure, the regular expression generation program causes the computer to execute the following processes.

  When the user of the regular expression generation device 100 designates an identifier with the keyboard 902 or the mouse 903, the identifier input unit 108 inputs the identifier from the keyboard 902 or the mouse 903 (step S501: identifier input processing). The attribute range condition input unit 101 is an attribute stored in association with an identifier input by the identifier input unit 108 from among a plurality of attribute range condition data stored in the magnetic disk device 920 in advance by the condition storage unit 107. Range condition data is read out and input (step S502: attribute range condition input process). After step S502, similar to the flowchart of FIG. 4 described in the first embodiment, the processes of steps S103 to S107 are executed.

  As described above, in the present embodiment, the regular expression generation device 100 includes regular expression generation rules (that is, attribute ranges) in a part of the storage area in the storage device 151 that can be referred to for processing for generating a regular expression. Area for storing (conditions), identification number, identification name (all are examples of identifiers), attribute value format and regular expression generation procedure (all are examples of information included in attribute range conditions) Remember in pairs. As the attribute range condition, the lower limit value and the upper limit value of the attribute may be specified each time as in the first embodiment, and only the attribute format may specify an identification number or an identification name for specifying the attribute format. At this time, the attribute range condition input unit 101 reads the format information and regular expression generation procedure corresponding to the specified identification number and identification name from the storage device 151, and the regular expression generation unit 104 and the regular expression combination unit 105. However, the regular expression may be generated according to the procedure. Alternatively, the attribute range condition input unit 101 inputs a lower limit value and an upper limit value of an attribute as a character string, and the regular expression generation unit 104 and the regular expression combination unit 105 analyze the input character string and separate them with a comma. The presence / absence or the like may be automatically determined.

  Further, an area for storing the regular expression generation rule is defined as a rewritable area, and the condition storage unit 107 includes an identification number and an identification name representing an attribute format, an attribute data type, a format, and a regular expression. Information such as the generation procedure may be added to this area.

  The area for storing the regular expression generation rule may be configured to be stored in the storage device 151 such as a disk device or a non-volatile memory and to be read from the processing device 152 that executes the regular expression generation procedure. However, it may be configured to be stored on a high-speed nonvolatile memory at the time of execution.

Embodiment 3 FIG.
In the present embodiment, differences from the first embodiment will be mainly described.

  In the present embodiment, a flow of processing for generating a regular expression for an attribute having a format different from that in the first embodiment will be described. The configuration of regular expression generating apparatus 100 in the present embodiment is the same as that shown in FIG. 1 described in the first embodiment. The operation of the regular expression generation device 100 (regular expression generation method, regular expression generation program processing procedure) is the same as that shown in FIG. 4 described in the first embodiment.

  Hereinafter, as in the first embodiment, the flow of processing for generating a regular expression will be described with an example. What is described here is a character string expressing a value X (attribute value X from lower limit value A to upper limit value B) that satisfies A ≦ X <B with respect to lower limit value A and upper limit value B of the attribute range condition. This is a flow of processing for generating a regular expression for matching.

Unlike the first embodiment, the attribute values here are expressed as follows.
Lower limit A: A ₁ A ₂ . . . A _{n-1 An}
Upper limit B: B ₁ B ₂ . . . B _m-1 B _m
A _i and B _j (1 ≦ i ≦ n, 1 ≦ j ≦ m) are each a single number or letter, and their ranges are v ₁ ≦ A _i and B _j ≦ v _q . The magnitude relationship between attribute values in the present embodiment is determined in the following order.
(1) A ₁ = B ₁ , A ₂ = B ₂ ,. . . , A _k−1 = B _k−1 (1 ≦ k ≦ n or m), B> A if B _k > A _k
(2) A ₁ = B ₁ , A ₂ = B ₂ ,. . . , A _n = B _n and m> n, B> A
A _i +1 is described to increase the value of A _i by 1. When A _i = v _j , A _i + 1 = v _{j + 1} . However, when A _i = v _q , A _i + 1 = v ₁ and further A _{i + 1} +1. Similarly, A _i −1 is described, and the value of A _i is decreased by 1. When A _i = v _j , A _i −1 = v _j−1 . However, when A _i = v ₁ , A _i −1 = v _q, and further A _{i + 1} −1. Increasing the attribute value A by 1 is described as A + 1, which means A _n +1. Similarly, reducing the attribute value A by 1 is described as A-1, and is assumed to be A _n -1.

  Attribute values having such characteristics include a character string (in lexicographic order) and a decimal part of a decimal point (value after the decimal point).

Here, if the lower limit value A and the upper limit value B are equal, it is only necessary to output the following regular expression without executing step S102.
Regular expression: “A ₁ A ₂ ... A _n-1 A _n ”

  Hereinafter, a case where the lower limit value and the upper limit value are not equal will be described.

  In step S102, the calculation unit 102 divides the attribute value into three regions, lower, middle, and upper. At this time, it is better to consider the lower limit value and the upper limit value according to the smaller number of digits.

First, the middle region is obtained for the r-digit lower limit value A ′ and upper limit value B ′ as follows.
Lower limit value A ′: A ₁ A ₂ . . . A _r-1 A _r
Upper limit B ′: B ₁ B ₂ . . . B _r-1 B _r
Here, r is the smaller of n and m. FIG. 10 shows a flow of processing for obtaining the middle region. In FIG. 10, step S201 in FIG. 5 is set to “i = 1”, steps S204 and S206 are set to “i = i + 1”, and step S207 is set to “i ≦ r?”.

In FIG. 10, the calculation unit 102 compares the values of the same digit of the lower limit value A ′ and the upper limit value B ′ of the attribute value in order from the least significant digit (first digit) (step S601) by the CPU 911 (step S601). S602). When the value of A ′ and B ′ is the same for a certain digit (i-th digit), the arithmetic unit 102 also sets the same digit (L _i , U _i ) of L and U to the value (A _i ) ( In step S603), A ′ and B ′ are compared for the next digit (step S604). When the compared digits have different values between A ′ and B ′, the calculation unit 102 sets the same digit (L _i ) of L to a value (A _i +1) that is one greater than the value of A ′, and U The same digit (U _i ) is set to a value (B _i −1) that is one smaller than the value of B ′ (step S605). For each digit from the next digit to the r-th digit (steps S606 and S607), L is set to the minimum value (v ₁ ) of that digit, and U is set to the maximum value (v _q ) of that digit. (Step S608). As a result, the lower limit value L and the upper limit value U of the middle region are obtained. At this time, the attribute value storage unit 103 stores L and U in the RAM 914.

According to the above procedure, the calculation unit 102 can obtain the lower region (A ′ to L−1), the middle region (L to U), and the upper region (U + 1 to B ′) as follows.
Subregion: A ₁ A ₂ . . . A _r-1 A _{r to} A ₁ . . . A _k (v _q ) _k−1 . . . (V _q ) _r
Middle region: A ₁ . . . A _k-1 (A _k +1) (v ₁ ) _{k + 1} . . . (V ₁ ) _r -B ₁ . . . B _k−1 (B _k −1) (v _q ) _{k + 1} . . . (V _q ) _r
Upper region: B ₁ . . . B _k (v ₁ ) _k−1 . . . (V ₁ ) _{r to} B ₁ B ₂ . . . B _r-1 B _r
However, A ₁ = B ₁ ,. . . , A _k−1 = B _k−1 (1 ≦ k ≦ r)
At this time, the attribute value storage unit 103 stores the lower limit value A ′, the upper limit value B ′, the first value (L−1), and the second value (U + 1) in the RAM 914.

Subsequently, when n> m, the calculation unit 102 adds the r + 1-th to n-th digits to the lower area.
Lower region: A ₁ . . . A _r A _{r + 1} . . . _{An to} A ₁ . . . A _k (v _q ) _k−1 . . . (V _q ) _r (v _q ) _{r + 1} . . . (V _q ) _n
On the other hand, when n <m, the calculation unit 102 adds the r + 1-th to m-th digits to the upper area.
Upper region: B ₁ . . . B _k (v ₁ ) _k−1 . . . (V ₁ ) _r (v ₁ ) _{r + 1} . . . (V ₁ ) _{m to} B ₁ . . . B _r B _{r + 1} . . . B _m

In step S103, the regular expression generation unit 104 generates a regular expression for the middle region. The regular expression of the middle region depends only on the values of A _k and B _k of the middle region, and can be generated as follows. Since the values from the first digit to the (k−1) th digit can be processed as common parts in step S106, they are omitted here.
Regular expression in the middle region: “[(A _k +1) − (B _k −1)]”
Here, when B _k −A _k = 1, (A _k +1)> (B _k −1) is satisfied. In this case, the regular expression of the middle region is not output. Other than that, it can process similarly.

FIG. 11 shows the flow of processing for generating a regular expression corresponding to the following attribute value ranges.
Lower limit: A _k A _k−1 . . . _An
Upper limit value: (v _j ) _k (v _q ) _k−1 . . . (V _q ) _n (where v _j ≧ A _k )

The processing flow in FIG. 11 is almost the same as that shown in FIG. 6, and the regular expression generation unit 104 advances the processing from the lowest digit to the higher digit. In step S _< b> 701, the regular expression generation unit 104 sets “A _k ... A _n−1 [A _n −v _q ]” as an initial value in the regular expression storage area (E) in the RAM 914. In step S702 and subsequent steps, the processes in steps S704 to S706 are repeated from the second least significant digit to the k + 1th digit. If it is determined in step S703 that the processing target is lower than the k-th digit (YES), the process is divided in step S704 depending on whether or not the value of the digit is v _q . In the case of v _q (YES), the regular expression generation unit 104 shifts to the next digit process without outputting anything. When it is not v _q (NO), the regular expression generation unit 104 adds “| A _k ... A _i-1 [(A _i +1) −v _q ] at the end of the output area (E) of the regular expression. ”Is added, and the process proceeds to the next digit. In step S703, if the processing up to the (k + 1) th digit has been completed (NO), the process proceeds to step S707. If A _k and v _j are equal in step S707 (YES), the regular expression generation unit 104 ends the process without doing anything. If A _k and v _j are not equal (NO), the regular expression generation unit 104 proceeds to step S708 and adds “| [(A _k +1) −v _j ]” to the end of the regular expression storage area (E). Then, the process ends. What is stored in the regular expression storage area (E) when the processing is completed is a regular expression corresponding to the above range.

_A 1 _{= B} 1, the flow of regular expression generation processing of the lower region, in FIG. 11 in step S104. . . , A _k−1 = B _k−1 (1 ≦ k ≦ n), this corresponds to the case where the lower limit value and the upper limit value are set as follows for k.
Lower limit: A _k A _{k + 1} . . . _An
Upper limit value: A _k (v _q ) _{k + 1} . . . (V _q ) _n
In step S104, the regular expression of the lower region generated by the regular expression generation unit 104 is as follows. Since the values from the first digit to the (k−1) th digit can be processed as common parts in step S106, they are also omitted here.
Regular expression of the _{sub-regions: "A k A k + 1} ... A n-1 [A n -v q] | A k A k + 1 ... A n-2 [(A n-1 +1) -v q] | ... | A _k [(A _{k + 1} +1) −v _q ] ”

FIG. 12 shows the flow of processing for generating a regular expression corresponding to the following attribute value ranges.
Lower limit value: (v _j ) _k (v ₁ ) _{k + 1} . . . (V ₁ ) _m (where v _j ≦ B _k )
Upper limit value: B _k B _{k + 1} . . . B _m

The processing flow in FIG. 12 is almost the same as that shown in FIG. 7, and the regular expression generation unit 104 advances the processing from the lowest digit to the higher digit. In step S801, the regular expression generation unit 104 sets “B _k ... B _m−1 [v _1- (B _m −1)]” as an initial value in the regular expression storage area (E) in the RAM 914. To do. In step S802 and subsequent steps, the processes in steps S804 to S806 are repeated from the second least significant digit to the k + 1th digit. In step S803, if the processing of the target is lower than the k-th digit (YES), in step S804, the carving process depending on whether the value of that digit is _{v 1} or. In the case of v ₁ (YES), the regular expression generation unit 104 shifts to the next digit process without outputting anything. When it is not v ₁ (NO), the regular expression generation unit 104 adds “| B _k ... B _{i + 1} [v ₁ − (B _i −1)]” at the end of the regular expression output area (E). To move to the next digit processing. In step S803, if the processing up to the (k + 1) th digit has been completed (NO), the process proceeds to step S807. In step S807, when B _k and v _j are equal (YES), the regular expression generation unit 104 ends the process without doing anything. If B _k and v _j are not equal (NO), the regular expression generation unit 104 proceeds to step S808 and adds “| [v _j − (B _k −1)]” to the end of the regular expression storage area (E). Add and finish the process. What is stored in the regular expression storage area (E) when the processing is completed is a regular expression corresponding to the above range.

The flow of regular expression generation processing for the upper region in step S105 is as follows: A ₁ = B ₁ ,. . . , A _k−1 = B _k−1 (1 ≦ k ≦ m), this corresponds to the case where the lower limit value and the upper limit value are set as follows for k.
Lower limit: B _k (v ₁ ) _{k + 1} . . . (V ₁ ) _m
Upper limit value: B _k B _{k + 1} . . . B _m
In step S105, the regular expression of the upper region generated by the regular expression generation unit 104 is as follows. Since the values from the first digit to the (k−1) th digit can be processed as common parts in step S106, they are also omitted here.
Regular expression of upper region: “B _k B _{k + 1} ... B _m−1 [v ₁ − (B _m −1)] | B _k B _{k + 1} ... B _m−2 [v ₁ − (B _{m−1 -1)] | ... | B k} [v 1 - (B k + 1 -1)] "

In step S106, the regular expression combining unit 105 combines the regular expressions of the lower, middle, and upper regions generated individually in steps S103 to S105, and the combined regular expressions are omitted in steps S103 to S105. A common part (from the first digit to the (k−1) th digit) is added to generate a regular expression corresponding to the attribute range condition. This regular expression has the following form from the common part of the lower limit value and upper limit value of the attribute range condition and the regular expressions of the lower, middle, and upper areas.
“A ₁ ... A _k-1 (<Regular expression of lower region> | <Regular expression of middle region> | <Regular expression of upper region>)”
In addition, the regular expression generated when there is no middle region has the following format.
“A ₁ ... A _k-1 (<Regular expression in lower region> | <Regular expression in upper region>)”

In such a regular expression, character collation is stopped when a character string is collated up to 1 or n or m characters described in the regular expression. Therefore, a character string longer than that may hit, but may not know the position at the end of the character string. Therefore, when it is desired to know the position of the end of the character string hitting the regular expression, “[v ₁ −v _q ] *” may be added to the end of the regular expression.

In the regular expression, not only the value X satisfying A ≦ X <B but also the value v _i X is hit. Therefore, in order to avoid such a hit, an exclusion character designation “[^ v ₁ −v _q ]” may be added to the head of the regular expression.

A specific example in the case where the above method is applied to a lowercase character string (in the case of either one type of lowercase alphabet or lowercase alphabet) is shown. Here, v ₁ = a and v _q = z.

(Example 3-1) Attribute range condition: “end” to “start”
Lower region: “end” to “ezz”
Middle region: “faa” to “rzz”
Upper area: “saaa” to “start”
Regular expression: “(en [d−z] | e [o−z]) | [fr] | (star [a−s] | sta [a−q] | s [a−s])”

  A specific example in which the above method is applied to the lower limit value A and the upper limit value B satisfying 0 <A and B ≦ 1 is shown.

(Example 3-2) Attribute range condition: 0.00321 to 0.876
Lower region: 0.00321 to 0.09999
Middle region: 0.100 to 0.799
Upper area: 0.800 to 0.876
Regular expression: “0. ((0032 [1-9] | 003 [3-9] | 00 [4-9] | 0 [1-9]) | [1-7] | (87 [0-5] | 8 [0-6])) "

  In the description so far, the case where both the lower limit value A and the upper limit value B of the attribute value are specified has been shown. Here, a case where the upper limit value B is not specified or a case where the upper limit value is specified as “infinity” will be described. When the maximum value B ′ exists as the attribute data type, the regular expression combining unit 105 may generate a regular expression from the lower limit value A to the upper limit value B ′. When there is no maximum value as the data type of the attribute, it is better to process as follows.

First, the regular expression combining unit 105 generates a regular expression for the maximum value of attribute values having the same number of digits as the lower limit value A. That is, a regular expression is generated for the following n-digit lower and upper limit values.
Lower limit A: A ₁ . . . _An
Upper limit B ′: (v _q ) ₁ . . . (V _q ) _n
In addition, the regular expression combining unit 105 performs (v _q ) ₁ . . . (V _q ) _n . . . The regular expression “v _q {n} [v ₁ −v _q ] * [v ₂ −v _q ]” is added. The generated regular expression is in the following format.
Regular expression: “<Regular expression in the range of A to B ′> | v _q {n} [v ₁ −v _q ] * [v ₂ −v _q ]”

A case where the lower limit value A is not specified or a case where the lower limit value is specified as “infinitesimal” will be described. First, if there is a minimum value A ′ as an attribute data type, the regular expression combining unit 105 may generate a regular expression for the lower limit value A ′ and the upper limit value B. In other cases, a regular expression may be generated for the lower limit A ′ and the upper limit B as follows.
Lower limit value A ′: (v ₁ ) ₁
Upper limit B: B ₁ . . . B _m

  There may be two or more value ranges for each digit of the attribute such that uppercase and lowercase letters are used for letters and full-width and half-width letters are used for letters. In that case, as in the attribute of the first embodiment, the corresponding regular expression can be generated by using the selection “|” and the character class to describe them side by side.

  As described above, according to the regular expression generating apparatus 100 according to the present embodiment, the lower limit value is determined from the attribute range condition that specifies the lower limit value, upper limit value, format, etc. of the attribute value having characteristics such as a character string. A regular expression for collating a character string representing an attribute value included in the range from to the upper limit value can be automatically generated. As a result, a regular expression for matching complicated attribute range conditions, which has been difficult to describe accurately in the past, can be easily obtained in a short time without requiring special knowledge or trial and error.

Embodiment 4 FIG.
In the present embodiment, differences from the first embodiment will be mainly described.

  In the present embodiment, the flow of processing for generating a regular expression for an attribute having a hierarchical structure composed of a plurality of attribute values and delimiters that separate attribute values will be described. The configuration of regular expression generating apparatus 100 in the present embodiment is the same as that shown in FIG. 1 described in the first embodiment. The operation of the regular expression generation device 100 (regular expression generation method, regular expression generation program processing procedure) is the same as that shown in FIG. 4 described in the first embodiment. In order to generate the regular expression of the attribute having the hierarchical structure as described above, the regular expression generating apparatus 100 is the same as in the first and third embodiments from the highest hierarchy in the hierarchical structure toward the lower hierarchy. The regular expression is generated by applying the above procedure.

  In the present embodiment, the user of the regular expression generation apparatus 100 specifies an attribute upper limit value, lower limit value, delimiter, hierarchy order, attribute format of each hierarchy, value range, and the like as attribute range condition data. In step S101, the attribute range condition input unit 101 inputs the attribute range condition data. That is, the attribute range condition input unit 101 is an attribute value having a hierarchical structure in which the attribute value uses a delimiter as the format of the attribute value, and each of the portions where the entire attribute value is delimited by the delimiter The attribute range condition data indicating that it is one layer is input. Attribute values having such a hierarchical structure include date, time, IP (Internet / Protocol) address, decimal number, and the like. For example, the date has a hierarchical structure consisting of three layers of year, month and day from the top, and a slash “/” is often used as a delimiter. Further, when the attribute value is a date, each layer is a positive integer value, the range of the month layer is 1 to 12, and the range of the day layer is 1 to 31 (or 28, 29, 30). . For example, if the attribute value is date or time, the attribute range condition input unit 101 inputs attribute range condition data indicating that the attribute value is date or time as the format of the attribute value. For example, if the attribute value is an IP address, the attribute range condition input unit 101 inputs attribute range condition data indicating that the attribute value is an IP address as the format of the attribute value.

  In step S <b> 102, the calculation unit 102 calculates the first value and the second value with respect to the entire attribute value with each layer as one digit.

  In step S103, when there is an attribute value between the first value and the second value, the regular expression generation unit 104 sets the middle region data to the entire attribute value with each layer as one digit. Generate. Thereafter, the CPU 911 further converts the middle region data into data representing each layer in a regular expression. Further, in step S104, the regular expression generation unit 104 generates lower area data for each attribute value with each layer as one digit. After that, the CPU 911 converts the lower area data into data representing each hierarchy by a regular expression. Similarly, in step S105, the regular expression generation unit 104 generates upper area data for each attribute value, with each layer as one digit. After that, the CPU 911 converts the upper area data into data representing each hierarchy with a regular expression.

  As described above, in the present embodiment, the regular expression generation device 100 uses the regular expression to express the attribute range condition that specifies the upper limit value and lower limit value of the attribute value having a hierarchy composed of a plurality of values and delimiters. Or a search condition generation program for executing this method on a computer. In this method, each value is converted into a regular expression according to the same procedure as in the first and third embodiments in order from the highest hierarchy to the lowest hierarchy.

  In the search condition generation method, for example, the date attribute range condition is converted into a regular expression. Also, for example, the time attribute range condition is converted into a regular expression. For example, the attribute range condition of the IP address is converted into a regular expression.

Hereinafter, similarly to Embodiments 1 and 3, the flow of processing for generating a regular expression will be described with an example. What is described here is a character string representation of a value X that satisfies A ≦ X ≦ B (attribute value X from the lower limit value A to the upper limit value B) with respect to the lower limit value A and the upper limit value B of the attribute range condition. This is a flow of processing for generating a regular expression to be accepted. Here, the delimiters are <d ₁ ><d ₂ >. . . Assuming that attribute values are expressed as follows:
Lower limit A: A ₁ <d ₁ > A ₂ <d ₂ >. . . <D _n-1 > A _n
Upper limit B: B ₁ <d ₁ > B ₂ <d ₂ >. . . <D _n-1 > B _n
Here, A _i and B _i (1 ≦ i ≦ n) represent attribute values of one or more digits in each layer, and their value ranges are V _i ^min ≦ A _i and B _i ≦ V _i ^max .

In step S102, the calculation unit 102 regards each layer as a one-digit value and divides the whole into lower, middle, and upper regions. The division procedure at this time is performed by the same procedure as shown in FIG. That is, the attribute range conditions A to B are divided as follows. In an attribute having a hierarchical structure, if the attribute values of the second and lower layers (that is, the layers other than the highest layer) are attribute values in the format of the first embodiment, V _i ^min and V _i ^max are defined. Conceivable. In other cases, the minimum value and the maximum value may be considered within the range of the same number of digits as A _i .
Lower region: A ₁ <d ₁ > A ₂ <d ₂ >. . . <D _n-1 > A _{n to} A ₁ <d ₁ > V ₂ ^max <d ₂ >. . . <D _n-1 > V _n ^max
Middle region: (A ₁ +1) <d ₁ > V ₂ ^min <d ₂ >. . . <D _n-1 > V _n ^min ~ (B ₁ -1) <d ₁ > V ₂ ^max <d ₂ >. . . <D _n-1 > V _n ^max
Upper region: B ₁ <d ₁ > V ₂ ^min <d ₂ >. . . <D _n-1 > V _n ^{min to} B ₁ <d ₁ > B ₂ <d ₂ >. . . <D _n-1 > B _n

In step S <b> 103, the regular expression generation unit 104 can generate a regular expression as it is by generating a regular expression for each hierarchy in the middle region.
Regular expression in the middle region: “<Regular expression of (A ₁ +1) to (B ₁ −1)><Regular expression of d ₁ ><V ₂ ^{min to} V ₂ ^max ><d ₂ > ... <d _n-1 ><regular expression of V _n ^{min to} V _n ^max > ”
The regular expression generation unit 104 can use a procedure similar to that shown in the first and third embodiments according to the format of each attribute value as a method for generating a regular expression for each layer. That is, the regular expression generation unit 104 divides the range of values into lower, middle, and upper regions for each layer, similarly to the processing performed by the calculation unit 102, generates a regular expression for each region, and combines the regular expressions. Similar to the processing performed by the unit 105, the generated regular expression is written in the following format.
Regular expression: “(<regular expression in the lower area of the i hierarchy> || <regular expression in the middle area of the i hierarchy> || regular expression in the upper area of the i hierarchy>)”
As a result, the regular expression generation unit 104 can convert the regular expression in the middle region, which treats each hierarchy as one digit, into a regular expression including a regular expression corresponding to each hierarchy.

Regarding the lower region, in step S104, the regular expression generation unit 104 divides the second and lower layers into lower and middle regions (which can be considered as lower and upper) in the same manner as described above. The reason why there is no upper region (it can be considered that there is no middle region) is because the value of the second layer of the upper limit value of the original lower region is the maximum value V ₂ ^max of the attribute value range. is there. Thereby, the lower region can be further divided into a lower region and a middle region.
Lower region: A ₁ <d ₁ > A ₂ <d ₂ >. . . <D _n-1 > A _{n to} A ₁ <d ₁ > A ₂ <d ₂ > V ₃ ^max <d ₃ >. . . <D _n-1 > V _n ^max
Middle region: A ₁ <d ₁ > (A ₂ +1) <d ₂ > V ₃ ^min <d ₃ >. . . <D _n-1 > V _n ^{min to} A ₁ <d ₁ > V ₂ ^max <d ₂ >. . . <D _n-1 > V _n ^max
Subsequently, the regular expression generation unit 104 generates a regular expression in the middle region in the same procedure as in step S103, and further divides the next layer and lower in the lower region. In this way, by repeating the division into the lower and middle regions and the generation of the regular expression in the middle region up to the lowest layer, the regular expression generation unit 104 has treated each layer as one digit. A regular expression of a region can be converted into a regular expression including a regular expression corresponding to each layer.

Regarding the upper area, in step S105, the regular expression generating unit 104 similarly divides the second hierarchy and lower into the middle and upper areas (which can be considered as the lower and upper areas). The reason why there is no lower region (it can be considered that there is no middle region) is because the value of the second layer of the lower limit value of the original upper region is the minimum value V ₂ ^min of the value range of the attribute. is there. Thus, the upper area can be further divided into a middle area and an upper area.
Middle region: B ₁ <d ₁ > V ₂ ^min <d ₂ >. . . <D _n-1 > V _n ^{min to} B ₁ <d ₁ > (B ₂ -1) <d ₂ > V ₃ ^max <d ₃ >. . . <D _n-1 > V _n ^max
Upper region: B ₁ <d ₁ > B ₂ <d ₂ > V ₃ ^min <d ₃ >. . . <D _n-1 > V _n ^{min to} B ₁ <d ₁ > B ₂ <d ₂ >. . . <D _n-1 > B _n
Subsequently, the regular expression generation unit 104 generates a regular expression for the middle region in the same procedure as in step S103, and similarly divides the next layer and lower in the upper region. In this way, by repeating the division into the middle and upper regions and the generation of the regular expression in the middle region up to the lowest layer, the regular expression generation unit 104 has treated each layer as one digit. A regular expression of a region can be converted into a regular expression including a regular expression corresponding to each layer.

In the regular expression generation processing in steps S104 and S105, when the values of all layers below the k-th layer (2 ≦ k ≦ n) take the range of all values, that is, the value range is divided in the following cases do not have to.
Lower limit: A ₁ <d ₁ >. . . _{<D k-2> A k} -1 <d k-1> V k min <d k>. . . <D _n-1 > V _n ^min
Upper limit value: B ₁ <d ₁ >. . . <D _k-2 > B _k-1 <d _k-1 > V _k ^max <d _k >. . . <D _n-1 > V _n ^max
And the regular expression production | generation part 104 can produce | generate the regular expression with respect to the (k-1) th digit or less as follows.
Regular expression: "[A _k-1 -B _k-1 ] <d _k-1 ><regular expression of V _k ^{min to} V _k ^max ><d _k > ... <d _n-1 ><V _n ^min Regular expression of ~ V _n ^max > ”

In step S106, the regular expression combining unit 105 combines the lower, middle, and upper region regular expressions individually generated in steps S103 to S105 to generate a regular expression corresponding to the attribute range condition as follows. To do.
"<Regular expression in lower region> | <Regular expression in middle region> | <Regular expression in upper region>"
The regular expression generated when there is no middle-level area has the following format.
"<Regular expression in lower area> | <Regular expression in upper area>"

  A specific example of applying the above method to a date is shown. As a typical date format, it is assumed here that the date is separated by a slash “/”.

  (Example 4-1) Attribute range condition: 1996/11/15 to 2006/9/20

The attribute range condition input unit 101 designates the delimiter “/”, the type of attribute value (date), the year / month / day order, etc. in addition to the lower limit value and the upper limit value as input of the attribute range condition. Here, as in the second embodiment, the condition storage unit 107 stores a plurality of types of date formats in a part of the storage area in the storage device 151 that can be referred to for processing for generating a regular expression. Alternatively, the identifier input unit 108 may automatically select a corresponding date format by designating an identifier. In this case, the attribute range condition input unit 101 is stored in association with the identifier input by the identifier input unit 108 from among a plurality of attribute range condition data stored in advance in the storage device 151 by the condition storage unit 107. Read and input the attribute range condition data. Then, a regular expression is generated based on the attribute range condition data. Alternatively, the calculation unit 102, the regular expression generation unit 104, and the like may automatically identify the date format from the lower limit value and the upper limit value specified by the attribute range condition input unit 101. For example, if the lower limit is "A _3-year A ₂ May A ₁ day" _{(A 3, A 2, A} 1 is any number) has been designated as the delimiter in the "year", "month", "day" From the left, it can be easily recognized that it is a higher hierarchy. Here, the date is treated as if it is a three-digit attribute A ₃ A ₂ A ₁ consisting of attribute elements in the range of 0 ≦ A ₃ , 1 ≦ A ₂ ≦ 12, 1 ≦ A ₁ ≦ 31. You can also.

According to the above procedure, in step S102, the calculation unit 102 can divide the attribute range of this example into lower, middle, and upper regions as follows.
Lower region: 1996/11/15 to 1996/12/31
Middle region: 1997/1/1 to 2005/12/31
Upper area: 2006/1/1 to 2006/9/20

In step S103, the regular expression generation unit 104 generates a regular expression for the middle region as follows.
Regular expression of middle region: “<regular expression of 1997-2005> / <regular expression of 1-12> / <regular expression of 1-31>”

In step S104, the regular expression generation unit 104 can further divide the lower region (1996/11/15 to 1996/12/31) into a lower region and a middle region.
Lower region: 1996/11/15 to 1996/11/31
Middle region: 1996/12/1 to 1996/12/31
Thus, the regular expression of the lower area of the original attribute range is generated as follows.
Regular expression of lower region (1996/11/15 to 1996/12/31): “1996 / (11 / <regular expression of 15 to 31> | 12 / <regular expression of 1 to 31>)”

In step S105, the regular expression generation unit 104 can further divide the upper region (2006/1/1 to 2006/9/20) into a middle region and an upper region.
Middle region: 2006/1/1 to 2006/8/31
Upper area: 2006/9/1 to 2006/9/20
Thus, the regular expression of the upper area of the original attribute range is generated as follows.
Regular expression of upper region (2006/1/1 to 2006/9/20): “2006 (<regular expression of 1 to 8> / <regular expression of 1 to 31 >> | 9 / <regular expression of 1 to 20> ) ”

In step S106, the regular expression combination unit 105 configures the regular expression of the attribute range condition as follows.
Regular expression: "((1996 / (11 / <regular expression of 15 to 31 >> | 12 / <regular expression of 1 to 31>)) | (<regular expression of 1997 to 2005> / <regular expression of 1 to 12>) / <Regular expression of 1-31>) | (2006 (<Regular expression of 1-8> / <Regular expression of 1-31> | 9 / <Regular expression of 1-20>)) ”
If this is expanded, the following regular expression is obtained.
Regular expression: "(1996 / (11 / (1 [5-9] | 2 [0-9] | 3 [0-1]) | 12 / ([0-9] | [1-2] [0- 9] | 3 [0-1]))) | ((199 [7-9] | 200 [0-5]) / ([1-9] | 1 [0-2]) / ([0-9 ] | [1-2] [0-9] | 3 [0-1])) | (2006 / ([1-8] / ([0-9] | [1-2] [0-9] | 3 [0-1]) | 9 / ([1-9] | 1 [0-9] | 20))) "

In the example of the above date, the search is performed up to a date “11/31” which does not exist originally. Here, if it is desired to strictly process the day value range, a regular expression may be generated separately for each group having different day value ranges as in the following example.
Before modification: “<Regular expression of 1 to 12> / <Regular expression of 1 to 31>”
After correction: “(1 | 3 | 5 | 7 | 8 | 10 | 12) / <regular expression in the range of 1-31> | (4 | 6 | 9 | 11) / <regular expression in the range of 1-30 > | 2 / <regular expression in the range 1-28>"

  In the description so far, the case where both the lower limit value A and the upper limit value B of the attribute value are specified has been shown. Here, a case where the upper limit value B is not specified or a case where the upper limit value is specified as “infinity” will be described. When the maximum value B ′ exists as the attribute data type, the regular expression combining unit 105 may generate a regular expression from the lower limit value A to the upper limit value B ′. When there is no maximum value as the data type of the attribute, it is good to process by paying attention to the value of the first hierarchy.

First, the regular expression combining unit 105 has the largest value among the attribute values having the maximum value of the attribute value having the same number of digits m as the value of the first layer of the lower limit A, that is, A regular expression is generated with an upper limit value such that all values in the second layer and below are V _i ^max (2 ≦ i ≦ n). For example, if it is a regular expression for searching for dates after “2006/9/20”, a regular expression is generated for the attribute range condition of “2006/9/20” to “9999/12/31”. . Furthermore, a regular expression that searches for an arbitrary attribute value having a value of the first hierarchy of n + 1 digits or more is added. In the above example, a regular expression expressing a year of five digits or more can be written as “[1-9] [0-9] {4,}”.

A case where the lower limit value A is not specified or a case where the lower limit value is specified as “infinitesimal” will be described. First, if there is a minimum value A ′ as an attribute data type, the regular expression combining unit 105 may generate a regular expression for the lower limit value A ′ and the upper limit value B. In other cases, a regular expression may be generated with an attribute value having a minimum value V _i ^min (1 ≦ i ≦ n) as a value below the first layer as a lower limit value.

  The following applications are also conceivable for the search based on the attribute range condition of attributes having a hierarchical structure.

(Example 4-2) Attribute range condition: Weekdays from September 2006 to December 2006 A procedure for generating a regular expression for matching a character string representing a date satisfying the above conditions is shown. The above conditions differ from the attribute range conditions described so far in the following respects.
(1) Ranges are set in two layers of “month” and “day of the week”. In the example of the date attribute range condition shown above, ranges are set for “year” and “month”, but the substance as a value is a continuous value.
(2) No explicit range condition is set for “day” in the third hierarchy.
(3) “Day” and “Day of the week” change in conjunction. Strictly speaking, it is a value that is not in a hierarchical relationship.
Here, for the sake of simplicity, the attribute values of the date here are "year", "month", "day", and "day of the week" in order from the left. Assume that the delimiter between the slash “/” and “day” and “day of the week” is a blank character (strictly speaking, either a full-width space character or a half-width space character). In addition, the value range of “day of the week” is assumed to have values of V ₄ ^min = “SUN” and V ₄ ^max = “SAT”. Although the third hierarchy of this attribute range condition is not explicitly set, it may be considered that the value ranges from V ₃ ^{min to} V ₃ ^max . Such an attribute range condition is considered as follows.
Attribute range condition 1: 2006/9/1 to 2006/12/31
Attribute range condition 2: MON to FRI

After that, the regular expression combining unit 105 generates a regular expression for the attribute range condition 1 in accordance with the procedure for generating the regular expression for the date attribute range condition described above, and further generates a regular expression for the attribute range condition 2 following the delimiter. The expression “(MON | TUE | WED | THU | FRI)” may be combined. Thus, the regular expression finally generated is as follows.
Regular expression: “(2006 / (9 | 1 [0-2]) / ([1-9] | [12] [0-9] | 3 [01])) (MON | TUE | WED | THU | FRI ) ”

  Next, a specific example when the above method is applied to time will be shown. Here, it is assumed that each level of hour, minute and second is separated by a colon “:” and the time is expressed in 24 hours.

  (Example 4-3) Attribute range condition: 8:45:00 to 17:15:00

In step S102, the calculation unit 102 can divide this attribute range condition into lower, middle, and upper regions as follows.
Lower area: 8:45:00 to 8:59:59
Middle region: 9:00:00 to 16:59:59
Upper area: 17:00: 00 to 17: 15:00

From here, the regular expression generation unit 104 and the regular expression combination unit 105 can perform the same processing to generate a regular expression as follows.
Regular expression: “(8: (4 [5-9] | 5 [0-9]) :( 0 [0-9] | [1-4] [0-9] | 5 [0-9]) | (9 | 1 [0-6]): ([0-5] [0-9]) :( 0 [0-9] | [1-4] [0-9] | 5 [0-9]) | 17: ((0 [0-9] | 1 [0-4]) :( 0 [0-9] | [1-4] [0-9] | 5 [0-9]) | 15: 00 )) ”

In the above example, it is assumed that the regular expression corresponding to “00 to 59” that is the range of the second value is generated by the procedure shown in the first embodiment, and “0 [0-9] | [1-4 ] [0-9] | 5 [0-9] ", but this regular expression can be expressed in a simpler form such as" [0-5] [0-9] ". For patterns with a high frequency of appearance such as minutes and seconds of “00 to 59” in the time, a regular expression is stored in the magnetic disk device 920 and read out as necessary. By using this, the regular expression generation process can be further simplified. Examples of such patterns having a high appearance frequency include date “(0) 1 to 12”, “(0) 1 to 31”, time “0 to 12”, “0 to 24”, and “00 to 00”. 59 ”, IP address“ 0 to 255 ”, and the like are“ V _i ^{min to} V _i ^max ”.

  As shown below, when the time is expressed in 12 hours, it may be divided into morning and afternoon.

(Example 4-4) Attribute range condition: 8:45:00 AM to 5:15:00 PM
Such an attribute range condition is considered as follows.
Attribute range condition 1: 8: 45: 00 AM to 11:59:59 AM
Attribute range condition 2:00:00 PM to 5:15:00 PM
After the regular expressions are generated individually in the morning and afternoon in this way, the regular expression combining unit 105 may combine the regular expressions as follows.
Regular expression: “<Regular expression of attribute range condition 1> | <Regular expression of attribute range condition 2>”

  In the case of an IP address, four positive integers are separated by a period “.”, Which is a delimiter, and the upper layers are arranged in order from the left. Moreover, the numerical value range of each hierarchy is 0-255. Further, the IPv6 IP address is delimited by a colon “:” having eight hexadecimal values as delimiters. In either case, a regular expression is generated in the same manner by applying a procedure for dividing an area from an upper hierarchy toward a lower hierarchy, and applying the procedure of the first embodiment for each hierarchy value. Can do. Each hierarchy can be processed as an integer value of 0 or more, that is, an attribute value in the same format as in the first embodiment.

  (Example 4-5) Attribute range condition: 10.0.1.1 to 10.2.100.254

In step S102, the calculation unit 102 can divide this attribute range condition into lower, middle, and upper regions as follows.
Lower region: 10.0.1.1 to 10.0.255.255
Middle region: 10.1.0.0-10.1.25.255
Upper area: 10.2.0.0.0 to 10.2.10.254

From here, the processing is similarly performed toward the lower hierarchy. That is, in step S104, the regular expression generation unit 104 can further divide the lower area as follows.
Lower region: 10.0.1.1 to 10.0.1.255
Middle region: 10.0.2.0 to 10.0.255.255

In step S105, the regular expression generation unit 104 can further divide the upper area as follows.
Middle region: 10.2.0.0-10.2.0.99.255
Upper region: 10.2.100.0-10.2.210.254

Finally, in step S106, the regular expression combining unit 105 can generate a regular expression as follows.
Regular expression: “10 ¥. ((0 ¥. (1 ¥. ([1-9] | [1-9] [0-9] | 1 [0-9] [0-9] | (25 [0 -5] | 2 [0-4] [0-9])) | ([2-9] | [1-9] [0-9] | 1 [0-9] [0-9] | (25 [0-5] | 2 [0-4] [0-9])) ¥. ([0-9] | [1-9] [0-9] | 1 [0-9] [0-9] | (25 [0-5] | 2 [0-4] [0-9])))) | (1 ¥. ([0-9] | [1-9] [0-9] | 1 [0 -9] [0-9] | (25 [0-5] | 2 [0-4] [0-9])) ¥ ([0-9] | [1-9] [0-9] | 1 [0-9] [0-9] | (25 [0-5] | 2 [0-4] [0-9]))) | (2 ¥. (([0-9] | [1- 9] [0-9]) ¥. ([0-9] | [1-9] [0- ] | 1 [0-9] [0-9] | (25 [0-5] | 2 [0-4] [0-9])) | 100 ¥. ([0-9] | [1-9 ] [0-9] | 1 [0-9] [0-9] | (25 [0-4] | 2 [0-4] [0-9]))))) "

  The decimal is a numerical value in which an integer part and a decimal part are separated by a period “.”. The regular expression generation procedure applies the procedure of dividing the region in the order of the integer part that is the upper hierarchy and the decimal part that is the lower hierarchy, and applies the procedure of the first embodiment for the value of the integer part. By applying the procedure of the third embodiment for the value of the part, a regular expression can be similarly generated.

  (Example 4-6) Attribute range condition: 1.4142 to 6.63

In step S102, the calculation unit 102 can divide this attribute range condition into lower, middle, and upper regions as follows. Here, since the second hierarchy is an attribute value in the format of the third embodiment, the minimum value and the maximum value are considered within a range of values having the same number of digits. That is, since the value of the second layer of the lower limit value is 4 digits, the calculation unit 102 selects the maximum value of 4 digits as the upper limit value of the lower area. Further, since the value of the second layer of the upper limit value is two digits, the calculation unit 102 selects the minimum value of two digits as the lower limit value of the upper area.
Lower region: 1.4142 to 1.9999
Middle region: 2.00 to 5.99
Upper region: 6.00 to 6.63

Finally, in step S106, the regular expression combining unit 105 can generate the following regular expressions.
Regular expression: “(1 ¥. ((414 [2-9] | 41 [5-9] | 4 [2-9]) | ([5-9]))) | ([2-5] ¥. [0-9]) | (6 ¥. (([0-5]) | (6 [0-3]))) "

  When the delimiter is a metacharacter (character having a special meaning in the regular expression) used in the regular expression, an escape character (backslash or Japanese Windows (registered trademark)) immediately before the delimiter. In this environment, “¥” is mainly used). Such metacharacters include “|”, “?”, “*”, “+”, “.”, “(”, “)”, “{”, “}”, “[”, “] ”,“ ¥ ”,“ ^ ”,“ $ ”,“ <”,“> ”. However, the type of metacharacter may differ depending on the regular expression processing system.

  As described above, according to the regular expression generating apparatus 100 according to the present embodiment, attributes that specify a lower limit value, an upper limit value, a format, and the like of an attribute having a hierarchical structure composed of a plurality of attribute values and delimiters. From the range condition, it is possible to automatically generate a regular expression for collating a character string expressing an attribute value included in the range from the lower limit value to the upper limit value. As a result, a regular expression for matching complicated attribute range conditions, which has been difficult to describe accurately in the past, can be easily obtained in a short time without requiring special knowledge or trial and error.

Embodiment 5. FIG.
In the present embodiment, differences from the first embodiment will be mainly described.

  In the present embodiment, a flow of processing for generating a regular expression for searching a character string included in a specific range of text data described according to a predetermined syntax rule or format will be described. Here, not only a specific character string designated as a search target as in the prior art, but also a character string expressing an attribute value included in a specific range from a lower limit value to an upper limit value is a search target.

  FIG. 13 is a block diagram showing a configuration of regular expression generating apparatus 100 according to the present embodiment.

  In FIG. 13, the regular expression generation device 100 includes a text range condition input unit 109 in addition to the one shown in FIG. 1 described in the first embodiment. The regular expression generation device 100 may further include a condition storage unit 107 and an identifier input unit 108 as in the second embodiment.

  The text range condition input unit 109 inputs text range condition data from the input device 153. The text range condition data is text range condition data indicating a specific area of text described according to a predetermined syntax rule. A text range condition specifies a specific range in the text. For example, if the text is an e-mail, the text range condition input unit 109 can input text range condition data indicating a specific header field of the e-mail as a specific area of the text. In addition, for example, if the text is separated into a plurality of fields by a delimiter character such as CSV, the text range condition input unit 109 displays text indicating one of the plurality of fields as a specific area of the text. Range condition data can be entered.

  The attribute range condition input unit 101 inputs attribute range condition data indicating that the attribute value is included in the area indicated by the text range condition data input by the text range condition input unit 109 as the format of the attribute value.

  The regular expression generation unit 104 further includes text region data (hereinafter simply referred to as “regular expression” or “range”) that represents the region indicated by the text range condition data input by the text range condition input unit 109 in a regular expression. Is generated by the processing device 152.

  Based on the format indicated by the attribute range condition data input by the attribute range condition input unit 101, the regular expression combining unit 105 generates lower region data, upper region data, and middle region data generated by the regular expression generation unit 104. The regular expression data is generated by combining the text area data and expressing the specific area of the text including the attribute value by a regular expression.

  When the regular expression generation device 100 includes the condition storage unit 107 and the identifier input unit 108, the condition storage unit 107 stores a plurality of attribute range condition data and a plurality of text range condition data in the storage device 151 in advance. Remember. In addition, the condition storage unit 107 stores a combination of each attribute range condition data and each text range condition data in advance in the storage device 151 in association with a unique identifier. The identifier input unit 108 inputs an arbitrary identifier from the input device 153. The attribute range condition input unit 101 inputs the attribute range condition data of the combination stored in the condition storage unit 107 in association with the identifier input by the identifier input unit 108. Similarly, the text range condition input unit 109 inputs the text range condition data of the combination stored in the condition storage unit 107 in association with the identifier input from the identifier input unit 108.

  FIG. 14 is a flowchart showing a regular expression generation method according to the present embodiment. The flow shown in the flowchart of FIG. 14 corresponds to a processing procedure of a program (regular expression generation program) executed on a computer that implements the regular expression generation apparatus 100. In this processing procedure, the regular expression generation program causes the computer to execute the following processes.

  When the user of the regular expression generation apparatus 100 specifies text range condition data with the keyboard 902 or the mouse 903, the text range condition input unit 109 inputs the text range condition data from the keyboard 902 or the mouse 903 (step S901: Text Range condition input processing). Further, when the user of the regular expression generation apparatus 100 designates attribute range condition data indicating that an attribute value is included in the text area indicated by the text range condition data with the keyboard 902 or the mouse 903, an attribute range condition input unit 101 inputs the attribute range condition data from the keyboard 902 or the mouse 903 (step S902: attribute range condition input process). After step S902, similarly to the flowchart of FIG. 4 described in the first embodiment, the process of step S102 is executed.

  The regular expression generation unit 104 generates, in the CPU 911, text area data representing the text area indicated by the text range condition data input by the text range condition input unit 109 in step S901 (step S903: regular expression generation processing). Part of). After step S903, similarly to the flowchart of FIG. 4 described in the first embodiment, the processes of steps S103 to S105 are executed.

  The regular expression combining unit 105 generates the text region data generated by the regular expression generating unit 104 in steps S903 and S103 to S105 based on the format indicated by the attribute range condition data input by the attribute range condition input unit 101 in step S902. The CPU 911 combines the lower region data, the upper region data, and the middle region data (if the middle region data is not generated in step S103, only the text region data, the lower region data, and the upper region data are In addition to the attribute values from the lower limit value to the upper limit value stored by the attribute value storage unit 103, regular expression data that represents the text area including the attribute value as a regular expression is generated (step S3). S904: Regular expression combining process). After step S904, the process of step S107 is executed as in the flowchart of FIG. 4 described in the first embodiment.

  As described above, in the present embodiment, the regular expression generation device 100 sets the text range condition for selecting a specific region of text data described according to a predetermined syntax rule, and the specific range included in the value range of the attribute value. Select the attribute range condition to be selected as input and search condition generation method for converting these into regular expressions for detecting attribute values that match the attribute range condition from the above region, or execute this method on the computer A search condition generation program is implemented. In this method, a regular expression equivalent to the text range condition and a regular expression equivalent to the attribute range condition are generated, and these regular expressions are combined.

  In the search condition generation method, for example, a text range condition for selecting a specific header field of an e-mail and an attribute range condition are input, and these conditions are converted into regular expressions. In addition, for example, a text range condition for selecting a specific field of text data in which one line is divided into a plurality of fields by a predetermined delimiter and an attribute range condition are input, and these conditions are converted into a regular expression. .

  Further, the regular expression generation device 100 may provide an area for storing the conversion rule from the search condition to the regular expression in the storage device 151. In this case, the attribute range condition input unit 101, the text range condition input unit 109, and the identifier input unit 108 receive either or both of the attribute range condition and the text range condition, and an identifier as input. In the above area, for example, the condition storage unit 107 has a text range that varies depending on an identifier, a set of conversion rules for converting an attribute range condition that varies depending on the attribute value format into a regular expression, an identifier, and the syntax of the text data. One or both of a set of conversion rules for converting a condition into a regular expression are stored. Then, the regular expression generation unit 104 and the regular expression combination unit 105 take out the conversion rule associated with the input identifier from the area, and convert the input attribute range condition or text range condition into a regular expression according to the conversion rule. . An attribute range condition input unit 101, a text range condition input unit 109, and an identifier input unit 108 accept input of a pair of a conversion rule and an identifier for converting an attribute range condition or a text range condition into a regular expression, and a condition storage unit 107 may store the input conversion rule and identifier pair in the area.

  Hereinafter, the flow of processing for generating a regular expression will be described with an example.

  First, here is an example of text with default syntax rules and formats. The first example is e-mail. In the e-mail, the header field format is defined by RFC (Request For Comment) 2822 or the like. One item of the header field basically includes a field name, a field value, and a line feed (CRLF). The second example is a CSV file. A CSV file is a text file in which values of a plurality of fields are delimited by commas, and is often used to represent tabular data. Similar formats include TSV (Tab / Separated / Values) using a tab as a delimiter and a format using a space as a delimiter, both of which are delimited by multiple fields. Text.

  The regular expression to search for the character string included in a specific range in the text as described above is a regular expression for specifying a different range in the text for each text format, and the character string in that range. Can be realized by combining fixed keywords and regular expressions for searching. Therefore, in this embodiment, it is desirable to store in advance a regular expression for specifying a format and a range in a referenceable storage area in the storage device 151 included in the regular expression generation device 100. In this case, the input of the regular expression generation device 100 is a specification of a format indicated by the attribute range condition, a specification of a range to be searched indicated by the text range condition, and a regular expression for searching within the specified range. When the input is made, the regular expression generation device 100 generates a regular expression for specifying the corresponding range from the specification of the format and the range to be searched, and further generates the regular expression and the range within the range. Combine and output the regular expression to search.

  In addition, a process for generating a regular expression for performing a search specifying an attribute range condition as shown in Embodiments 1 to 4 for a specific range in the text is for specifying the text range. It can be realized by generating a regular expression, generating a regular expression corresponding to the attribute range condition according to the procedure shown in the first to fourth embodiments, and combining them.

An example of an email is shown. The syntax of the email header field is:
<Header field name>: <Attribute value><Line feed (CRLF)>

The syntax for attribute values that span multiple lines is as follows. In the header field of an e-mail, if the beginning of a line is a space character or a tab, it means that the line is a continuation of the previous line.
<Header field name>: <Attribute value><Line feed (CRLF)>
<Single-byte space or tab><Attributevalue><Line feed (CRLF)>
・ ・ ・ ・ ・ ・

At this time, the regular expression of the text range condition of the header field of the e-mail has the following form.
(1) When header field is one line Regular expression: “(^ | ¥ n) <Header field name>: [^ ¥ n] * <Regular expression of attribute value>”
(2) When header field extends over multiple lines Regular expression: “(^ | ¥ n) <Header field name>: [^ ¥ n] * (<Regular expression of attribute value> | (¥ n (¥ s | ¥ t) ) + [^ \ N] *) + <regular expression of attribute value>) "
Here, “¥ n” means a line feed, “¥ s” means a single-byte space, and “¥ t” means a tab.

For example, when searching for an attribute value that includes the character string “mail” in the title (Subject) of the electronic mail, the input of the regular expression generation device 100 may include the following information.
(A) Document format = “e-mail header field”
(B) Search target range (header field name) = “Subject”
(C) Range search condition (regular expression) = "mail"
As long as these conditions can be specified, the method of specifying them is not limited. For example, the text range condition input unit 109 may select (a) a document format and (b) a search target as a text range condition. A range is specified, and the attribute range condition input unit 101 may specify (c) a range search condition as the attribute range condition (at this time, the attribute range condition input unit 101 specifies the range search condition. This also indicates that the attribute value is included in the range indicated in the text range condition data).

In response to the above input, the regular expression generation unit 104 and the regular expression combination unit 105 set the <header field name> in the regular expression of the text range condition of the header field of the e-mail as follows as follows. ”Is output as a regular expression in which <regular expression of attribute value> is replaced with“ mail ”.
“(^ | ¥ n) Subject: [^ ¥ n] * ((mail) | (¥ n (¥ s | ¥ t) + [^ ¥ n] *) + (mail))”
Here, if it is known that the header field to be searched does not extend over a plurality of lines, the following regular expression may be simply output.
“(^ | ¥ n) Subject: [^ ¥ n] * (mail)”

A procedure for generating a regular expression for executing a search specifying a lower limit value and an upper limit value for a target such as a header field (Date) indicating the transmission date and time of an e-mail will be described. The input of the regular expression generation device 100 at this time is as follows.
(A) Document format = “e-mail header field”
(B) Search target range (header field name) = “Date”
(C) Search conditions (lower limit and upper limit) = “2005/10/1 to 2006/9/31”
For example, the text range condition input unit 109 specifies (a) the document format and (b) the search target range as the text range condition, and the attribute range condition input unit 101 sets (c) range as the attribute range condition. Specify search criteria for.

The attribute range condition input unit 101 also designates the following conditions as attribute range conditions.
(D) Attribute type = “date”
(E) Delimiter and hierarchy order = “day, month, year” (separator is a space character (strictly, a single-byte space), and the higher order from the right)
(F) Value range of the hierarchy “month” = “Jan to Dec”

From here, the regular expression generation unit 104 can generate a regular expression for the text range condition and a regular expression for the attribute range condition as follows.
Range: “(^ | ¥ n) <Header field name>: [^ ¥ n] * <Regular expression of attribute value>”
Attribute range (regular expression of attribute value): “(([1-9] | [12] [0-9] | 3 [0-1]) (Oct | Nov | Dec) 2005) | (([1- 9] | [12] [0-9] | 3 [0-1]) (Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep) 2006) "
Finally, when the regular expression combining unit 105 combines these, a desired regular expression can be obtained.

Even in the case of CSV text, the regular expression generation procedure is the same as in the case of electronic mail. When searching for a range sandwiched between the i-th and i + 1-th commas of each line of CSV format text by a regular expression, the regular expression for specifying the range is in the following format.
“(^ | ¥ n) ([^,] *,) {i} [^,] * <regular expression of attribute value>”

At this time, the input to the regular expression generation device 100 may include the following information.
(A) Document format = “CSV”
(B) Search target range (field number)
(C) Range search condition (regular expression)
For example, the text range condition input unit 109 specifies (a) the document format and (b) the search target range as the text range condition, and the attribute range condition input unit 101 sets (c) range as the attribute range condition. Specify search criteria for.

In some regular expressions, the value of each field is enclosed in double quotation marks """. When the value of each field is enclosed in double quotations, the value may include a comma or the value may include two consecutive double quotations. The regular expression of the text range at this time is in the following format (double quotations on the left and right edges highlight the regular expression as described above and are not part of the regular expression).
"(^ | \ N) (" ([^ "] |"")*",) {i} "([^"] | "") * <regular expression of attribute value>"

In the case of the TSV format, it is only necessary to replace the comma “,” which is a delimiter for the regular expression in the above text range with a tab (represented by “¥ t”) as follows.
"(^ | \ N) (" ([^ "] |"")*" \ t) {i} "([^"] | "") * <regular expression of attribute value>"

In the case of the text in the space delimited format, the comma “,” or tab that is the delimiter for the regular expression in the above text range need only be replaced with a single-byte space (represented by “¥ s”) as follows.
"(^ | \ N) (" ([^ "] |""" * "\ s) {i}" ([^ "] |"") * <regular expression of attribute value>"

  In addition, when a series of delimiters is regarded as a single delimiter, it is only necessary to change the single delimiter to the “<delimiter> +” format.

In the first and third embodiments, the method of strictly matching the attribute range condition by adding the expression “[^ v ₁ −v _q ]” to be excluded before the regular expression of the attribute range condition is shown. . When combining a regular expression of such an attribute range condition and a regular expression of a text range condition for searching for text in which fields such as CSV format or TSV format are separated by a delimiter, it is combined with the preceding exclusion character specification. And include the delimiter in the exclusion character specification. That is, a regular expression is constructed as follows.
Regular expression: “(^ | ¥ n) ([^ <delimiter>] * <delimiter>) {i} [^ v ₁ −v _q <delimiter>] * <regular expression of attribute value>”
Thereby, it is possible to prevent the delimiter character from being collated with “[^ v ₁ −v _q ]”.

  As described above, according to the regular expression generating apparatus 100 according to the present embodiment, the text range condition for designating a specific range and the regular expression or attribute range in the text described according to the predetermined syntax / format. From the condition, a regular expression for collating character strings included in the range can be automatically generated. As a result, a regular expression for matching complicated attribute range conditions, which has been difficult to describe accurately in the past, can be easily obtained in a short time without requiring special knowledge or trial and error.

  As mentioned above, although embodiment of this invention was described, you may implement combining 2 or more embodiment among these. Alternatively, one of these embodiments may be partially implemented. Or you may implement combining two or more embodiment among these partially.

1 is a block diagram illustrating a configuration of a regular expression generation device according to Embodiments 1, 3, and 4. FIG. It is a figure which shows an example of the external appearance of the regular expression production | generation apparatus in each embodiment. It is a figure which shows an example of the hardware resource of the regular expression production | generation apparatus in each embodiment. 5 is a flowchart showing a regular expression generation method according to the first, third, and fourth embodiments. 5 is a flowchart showing details of step S102 of FIG. 4 in the first embodiment. 5 is a flowchart showing details of step S104 in FIG. 4 in the first embodiment. 5 is a flowchart showing details of step S105 in FIG. 4 in the first embodiment. 6 is a block diagram illustrating a configuration of a regular expression generation device according to Embodiment 2. FIG. 10 is a flowchart showing a regular expression generation method according to the second embodiment. 6 is a flowchart showing details of step S102 in FIG. 4 in the third embodiment. 6 is a flowchart showing details of step S104 in FIG. 4 in the third embodiment. 6 is a flowchart showing details of step S105 of FIG. 4 in the third embodiment. FIG. 10 is a block diagram illustrating a configuration of a regular expression generation device according to Embodiment 5. 10 is a flowchart showing a regular expression generation method according to the fifth embodiment.

Explanation of symbols

  100 regular expression generator, 101 attribute range condition input unit, 102 arithmetic unit, 103 attribute value storage unit, 104 regular expression generation unit, 105 regular expression combination unit, 106 output unit, 107 condition storage unit, 108 identifier input unit, 109 Text range condition input unit, 151 storage device, 152 processing device, 153 input device, 154 output device, 901 display device, 902 keyboard, 903 mouse, 904 FDD, 905 CDD, 906 printer device, 910 system unit, 911 CPU, 912 Bus, 913 ROM, 914 RAM, 915 communication board, 920 magnetic disk drive, 921 operating system, 922 window system, 923 programs, 924 files, 940 Internet, 941 gateway Lee, 942 LAN.

Claims (12)

An attribute range condition input unit for inputting attribute range condition data indicating a lower limit value, an upper limit value and a format of the attribute value from an input device;
Based on the format indicated by the attribute range condition data input by the attribute range condition input unit, the attribute value is equal to or greater than the lower limit value indicated by the attribute range condition data input by the attribute range condition input unit, and the least significant digit A first value in which at least one digit is the maximum value of the digit and an attribute value equal to or lower than the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit, and at least 1 from the lowest digit A computing unit that computes the second value, the digit of which is the minimum value of the digit, by the processing device;
Attribute value storage that stores the lower limit value and the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit, and the first value and the second value calculated by the calculation unit in a storage device And
Lower region data representing the attribute value from the lower limit value to the first value stored by the attribute value storage unit in a regular expression, and the attribute value from the second value to the upper limit value stored by the attribute value storage unit If the attribute value exists between the first value and the second value stored in the attribute value storage unit, the upper region data representing the regular expression in the regular expression is generated by the processing device. A regular expression generating unit that generates intermediate region data representing a value in a regular expression by a processing device;
The lower region data, the upper region data, and the middle region data generated by the regular expression generation unit are combined by a processing device, and the attribute values from the lower limit value to the upper limit value stored in the attribute value storage unit are normalized. A regular expression generation apparatus comprising: a regular expression combining unit that generates regular expression data represented by an expression.   The arithmetic unit has the same number of digits as the lower limit value indicated by the attribute range condition data input by the attribute range condition input unit based on the format indicated by the attribute range condition data input by the attribute range condition input unit. The first value in which at least the digit other than the most significant digit is the maximum value of each digit and the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit have the same number of digits and at least other than the most significant digit The regular expression generation device according to claim 1, wherein the second value is a minimum value of which the minimum value of each digit is calculated.   The arithmetic unit is a first value having the same value as the lower limit value and the most significant digit indicated by the attribute range condition data input by the attribute range condition input unit, and the other digits being the maximum value of each digit, An upper limit value indicated by the attribute range condition data input by the attribute range condition input unit and a second value in which the most significant digit is the same value and the other digits are the minimum value of each digit are calculated. The regular expression generation device according to claim 2.   2. The regular expression according to claim 1, wherein the attribute range condition input unit inputs attribute range condition data indicating that the attribute value is one of a numerical value and a character string as a format of the attribute value. Generator. The attribute range condition input unit is an attribute value in which the attribute value has a hierarchical structure using a delimiter as a format of the attribute value, and each of the portions where the entire attribute value is delimited by the delimiter is one layer of the hierarchical structure Attribute range condition data indicating that
The calculation unit calculates a first value and a second value for each attribute value as a single digit for the entire attribute value,
The regular expression generation unit generates the lower area data and the upper area data for each attribute value as a single digit with respect to the entire attribute value, and then represents the lower area data and the upper area data in a regular expression. Converting, generating an intermediate region data when an attribute value exists between the first value and the second value, and further converting each layer into one represented by a regular expression The regular expression generation device according to claim 1.   The attribute range condition input unit inputs attribute range condition data indicating that the attribute value is one of a date, a time, and an IP (Internet Protocol) address as a format of the attribute value. Item 6. The regular expression generation device according to Item 5. The regular expression generation device further includes:
A text range condition input unit for inputting text range condition data indicating a specific area of text described according to a predetermined syntax rule from an input device;
The attribute range condition input unit inputs attribute range condition data indicating that the attribute value is included in an area indicated by the text range condition data input by the text range condition input unit as a format of the attribute value,
The regular expression generation unit further generates text region data representing the region indicated by the text range condition data input by the text range condition input unit with a regular expression by a processing device,
The regular expression combining unit, based on the format indicated by the attribute range condition data input by the attribute range condition input unit, lower region data, upper region data, and middle region data generated by the regular expression generation unit, The regular expression generation device according to claim 1, wherein the regular expression data is generated by combining the text area data and expressing the specific area of the text including the attribute value by a regular expression.   The regular expression generation device according to claim 7, wherein the text range condition input unit inputs text range condition data indicating a specific header field of an e-mail as the specific area of the text.   8. The regular expression according to claim 7, wherein the text range condition input unit inputs text range condition data indicating any one of the fields in which the text is separated by a delimiter as the specific area of the text. Generator. The regular expression generation device further includes:
A plurality of attribute range condition data and a plurality of text range condition data are stored in advance in a storage device, and a combination of each attribute range condition data and each text range condition data is associated with a unique identifier in advance. A condition storage unit for storing
An identifier input unit for inputting an arbitrary identifier from an input device;
The attribute range condition input unit inputs attribute range condition data of a combination stored by the condition storage unit in association with the identifier input by the identifier input unit,
The regular text range condition input unit according to claim 7, wherein the text range condition input unit inputs the text range condition data of the combination stored in the condition storage unit in association with the identifier input by the identifier input unit. Expression generator. The attribute range condition input unit of the regular expression generation device inputs attribute range condition data indicating the lower limit value, upper limit value and format of the attribute value from the input device,
Based on the format indicated by the attribute range condition data input by the attribute range condition input unit, the arithmetic unit of the regular expression generation apparatus is equal to or greater than the lower limit value indicated by the attribute range condition data input by the attribute range condition input unit. A first value in which at least one digit from the least significant digit is the maximum value of the digit, and an attribute value equal to or lower than the upper limit value indicated by the attribute range condition data input by the attribute range condition input unit And a processing device calculates a second value in which at least one digit from the least significant digit is the minimum value of the digit,
The attribute value storage unit of the regular expression generation device includes a lower limit value and an upper limit value indicated by the attribute range condition data input by the attribute range condition input unit, a first value calculated by the calculation unit, and a second value Store the value in a storage device,
The regular expression generation unit of the regular expression generation device stores lower region data representing the attribute value from the lower limit value to the first value stored in the attribute value storage unit in a regular expression, and is stored in the attribute value storage unit. High-order area data representing the attribute value from the second value to the upper limit value with a regular expression is generated by the processing device,
When a regular expression generating unit of the regular expression generating device has an attribute value between the first value and the second value stored by the attribute value storage unit, the regular value generating unit represents the attribute value by a regular expression. The middle region data is generated by the processing device,
The regular expression combining unit of the regular expression generating device combines the lower region data, the upper region data, and the middle region data generated by the regular expression generating unit with a processing device, and is stored in the attribute value storage unit. A regular expression generation method characterized by generating regular expression data representing an attribute value from a lower limit value to an upper limit value by a regular expression. Attribute range condition input processing for inputting attribute range condition data indicating the lower limit value, upper limit value and format of the attribute value from the input device;
Based on the format indicated by the attribute range condition data input by the attribute range condition input process, the attribute value is equal to or greater than the lower limit value indicated by the attribute range condition data input by the attribute range condition input process, and the least significant digit A first value in which at least one digit is the maximum value of the digit, and an attribute value equal to or lower than the upper limit value indicated by the attribute range condition data input by the attribute range condition input process, and at least 1 from the least significant digit An arithmetic process in which a processing unit calculates a second value whose digit is the minimum value of the digit;
Attribute value storage that stores the lower limit value and the upper limit value indicated by the attribute range condition data input by the attribute range condition input process, and the first value and the second value calculated by the calculation process in a storage device Processing,
Lower region data representing the attribute value from the lower limit value to the first value stored by the attribute value storage processing by a regular expression, and the attribute value from the second value to the upper limit value stored by the attribute value storage processing When the attribute value exists between the first value and the second value stored by the attribute value storage process, the upper region data representing the regular expression in the regular expression is generated by the processing device. A regular expression generation process for generating intermediate region data representing a value in a regular expression by a processing device;
The lower region data, the upper region data, and the middle region data generated by the regular expression generation process are combined by a processing device, and the attribute values from the lower limit value to the upper limit value stored by the attribute value storage process are normalized. A regular expression generation program that causes a computer to execute regular expression combining processing for generating regular expression data represented by an expression.

Images