JP2020086617A - Database and information processing system - Google Patents

Abstract

To provide a technique which converts data so as to prevent a database of a server from malfunctioning when a client saves the data in the database.SOLUTION: If a character likely to cause an information processing system to malfunction is included in a field of a database, a character string consisting of only characters other than characters likely to cause the information processing system to malfunction is substituted for the character and is stored in the database. When the stored field is read, an information processing apparatus is caused to execute processing of converting the characters after the substitution to the character before the substitution.SELECTED DRAWING: Figure 2

Description

The present invention relates to a program for processing a database.

Conventionally, software required for the first information processing apparatus and the second information processing apparatus is installed, the software installed in the first information processing apparatus is operated, and a database stored in the second information processing apparatus is operated. A program for processing is known. (For example, see Non-Patent Document 1)

Nico Nico Douga "< Company livestock raising drama> Business system has an illusion Episode 12 "DB Susume"" (URL: https://www.nicovideo.jp/watch/sm32753333) Viewed October 30, 2018 However <and > Is black brackets

However, the technique disclosed in Non-Patent Document 1 has a problem in that software must be installed in a plurality of information processing devices, and if the software settings are incorrect, the software may not operate correctly.

The present invention has been made in view of the above circumstances, and an object thereof is to have software installed in a first information processing device process a database stored in a second information processing device. The object is to provide a program and an information processing system that can be performed.

A program according to an aspect of the present invention is such that when a field of a database includes a character that may cause a malfunction of the information processing system, the character is not a character that may cause a malfunction of the information processing system. In the information processing device, a process of replacing a character string consisting of only one and storing it in the database, and a process of converting the character after the replacing to the character before the replacing when reading the stored field Let it run.

The program according to one aspect of the present invention is stored in a predetermined location (may be the first information processing apparatus or the second information processing apparatus connected to the first information processing apparatus via a communication unit). The process for operating the stored database is executed by the first information processing device.

According to one aspect of the present invention, a database can be processed. (Even when processing the program stored in the second information processing apparatus connected to the first information processing apparatus via the communication means, it is not necessary to install the software in the second information processing apparatus)

FIG. 3 is a block diagram showing an information processing device. 6 is a flowchart showing a procedure for the information processing apparatus according to the first embodiment to execute the processing described in the first embodiment. 3 is an explanatory diagram of an example of processing performed by the information processing apparatus according to the first embodiment. FIG. 3 is an explanatory diagram of an example of processing performed by the information processing apparatus according to the first embodiment. FIG. FIG. 6 is a diagram showing a configuration of a database processing unit according to the second embodiment. Missing number. Missing number. 3 is a block diagram showing the configuration of an information processing system according to Embodiment 2. FIG. 9 is a flowchart showing a procedure of processing in which the information processing apparatus according to the third embodiment executes a reading unit 501. Missing number. 9 is a flowchart showing a procedure of a process in which the information processing apparatus according to the sixth embodiment executes a writing unit 521. FIG. 16 is a diagram for explaining an example of processing performed by the information processing device according to the sixth embodiment. FIG. 16 is a diagram showing an example of a change storage unit 513 and data stored in the change storage unit 513 according to the eighth embodiment. 9 is a flowchart showing a procedure of processing executed by the reading unit 501 according to the third embodiment. The figure which shows the stream storage part 511 which concerns on Embodiment 4. The figure which shows the text memory|storage part 512 which concerns on Embodiment 5. 20 is a flowchart showing the procedure of a process in which the information processing apparatus according to the seventh embodiment executes an update storage unit 1310 that is a part of the changing unit 502. 10 is a flowchart showing a procedure of processing in which the information processing apparatus according to the seventh embodiment executes a deletion storage unit 1350 which is a part of the changing unit 502. The figure which shows an example of the change part 502 which concerns on Embodiment 11. 23 is a flowchart showing the procedure of processing performed by the information processing apparatus according to the eleventh embodiment. 20 is a flowchart showing a procedure in which the information processing apparatus according to the tenth embodiment searches for data in at least one of the change storage unit 513 and the text storage unit 512.

<Hardware configuration>
Embodiment 1
The hardware configuration of the above embodiment will be described with reference to FIG. FIG. 1 is a block diagram showing an information processing device. The information processing device 1 is mutually connected to another information processing device by a communication network N (for example, the Internet, a LAN (Local Area Network) or a mobile phone network). The information processing device 1 is, for example, a server device, a personal computer, a smartphone, or the like. The information processing device 1 includes a CPU (Central Processing Unit) 11, a storage unit 12, a RAM (Random Access Memory) 13, an input unit 14, a display unit 15, a communication unit 16 and a drive unit 17.

The CPU 11 is connected to each part of the hardware via a path. The CPU 11 includes, for example, one or more CPUs or multi-core CPUs. The CPU 11 controls each part of the hardware according to the program 12P (for example, stored in the storage unit 12. It may be stored in another part (for example, the recording medium 10)).

The storage unit 12 is, for example, a hard disk or a large capacity memory. The drive unit 17 reads information from the recording medium 10 (for example, an optical disc). The storage unit 12 stores various data and programs 12P required when the CPU 11 performs processing. The CPU 11 causes the drive unit 17 to read the program 12P recorded in the recording medium 10, and stores the read program 12P in the storage unit 12. The CPU 11 loads the program 12P from the storage unit 12 into the RAM 13 as necessary, and executes various processes according to the loaded program 12P. The program 12P may be downloaded from the outside of the information processing device 1 or may be stored in the storage unit 12 in advance. In this case, the information processing device 1 may not have the drive unit 17.

The RAM 13 is, for example, SRAM (Static Random Access Memory), DRAM (Dynamic Random Access Memory), or flash memory. The RAM 13 also functions as a storage unit, and temporarily stores various data generated when the CPU 11 executes various programs.

The input unit 14 is an input device such as a mouse or a keyboard, and transmits the received operation information to the CPU 11. The display unit 15 displays the image data transmitted from the CPU 11. The display unit 15 is, for example, a liquid crystal display. The communication unit 16 is, for example, a wireless LAN card, a mobile phone communication module, or the like, and transmits and receives various information via the communication network N.

<Embodiment 1>
In this embodiment, the database is saved as a flat file database, that is, plain text.

In the present embodiment, the first character (e.g. line feed) is the record boundary and the second character (e.g. comma) is the column boundary. That is, at least the same character as the first character and the second character must not exist in the field. Otherwise, when the database is processed, a malfunction occurs (the information processing device mistakenly recognizes a place that is not a record or column boundary as a record or column boundary). Hereinafter, a character that should not be present in the field is called an "out character", and a character that is not an out character is called a "safe character".

The OUT character is a character used for managing the database as described above and should not be used for any other purpose. In addition, future function expansion (for example, if two or more third characters are consecutive, the first and second characters existing after that are comments and are not edited by the program, The third character (eg, slash) must not be present in the field because the enclosed character string causes the program to perform a predetermined process (eg, change the color of the character). The third character is the out character.

As mentioned above, the OUT character must not be present in the field. Therefore, when writing a character string that has an OUT character (for example, "(,, ゜Д゜).") to the field, the OUT character must be a safe character (however, it is a safe character that is not the fourth character described later). It is necessary to convert the converted character string into a character string consisting of only) and to separate the converted portion and the other portion by a fourth character (for example, an equal sign). Strictly speaking, the fourth character is not an out character (because it may exist in the field as long as it separates the part that converts the out character into a string consisting of safe characters and the part that does not), It is a character that must not be present in the field other than to separate the out character from the safe character, so it may have to be treated as if it were an out character. (For example, "(=゜ω゜)ノ" is a character string that does not include the OUT character, but since the fourth character exists, the program may mistakenly recognize that there is a safe character converted from the OUT character. Therefore, the fourth character is not an out character, but must be converted into a character string consisting only of "safe characters that are not the fourth character".)

The out character is converted into a predetermined character string. (For example, the first character is OUT1, the second character is OUT2, the third character is OUT3, and the fourth character is OUT4.) The converted portion and the non-converted portion are separated by the fourth character. (That is, "(,, ゜Д゜)" is converted to "(=OUT2==OUT2=゜Д゜)" and saved in the database. "(=゜ω゜)ノ" is "(=OUT4 = ゜ω゜)ノ」, converted to and saved in the database.
(
Modification:
The out character is converted into a character code of each character or a character string created from the character code of each character (for example, a character code converted into a hexadecimal number). However, the line feed is converted into a specified character string (for example, OUT1). (For example, the first character is OUT1, the second character is 2C, the third character is 2F, and the fourth character is 3D.) The converted portion and the other portion are separated by the fourth character. (That is, "(,,゜Д゜)R(=゜ω゜)ノR(=,=;)/" (where R is a line feed) is "(=2C-2C=゜Д゜)=OUT1=( =3D=゜ω゜)ノ=OUT1=(=3D-2C-3D=;)=2F=”, and is stored in the database. Because there are multiple character codes that signify line breaks , OUT1, it is better to decide the converted character string.
)

When reading the character string stored in the database, the odd character (starting from 0th) from the out character (or the 4th character) to the safe character (the 4th character) is separated by the 4th character string. Since the character string has been converted to a character string that does not include (), the odd-numbered character (starting from 0th) is converted to an out character with the fourth character string as a boundary. (That is, if "(=OUT2==OUT2=゜Д゜)" is stored in the field, "(" "OUT2" "" "OUT2" "" "゜Д゜) with the 4th character as a boundary Of these, the odd-numbered ones (starting at 0) are “OUT2” and “OUT2”, so convert these to “,” “,”. And the fourth character Concatenation of character strings divided into boundaries makes "(,, ゜Д゜)".)

(
Modification:
When converting a character string in which the OUT character or the fourth character continues (for example, "(=,=;)" as described above, the fourth character continues (for example, "(=OUT4==OUT2==OUT4= ;)”), which is inconvenient. In this case, if the out character or the fourth character is continuous, the fourth character will be continuous in the converted character string (the continuous characters mean that Do not use the part where the 4th character continues as a safe character (excluding the 4th character) converted from the out character (including the 4th character). Replace (also called replacement) with a character (hereinafter referred to as the fifth character) (for example, "-") For example, "(=,=;)" is "(=OUT4==OUT2==OUT4=;)" However, the character string after conversion is reduced by replacing the portion where the fourth character is continuous two by one fifth character (for example, "(=OUT4-OUT2-OUT4=;)").
)

(
Modification:
When reading the character string stored in the database, the odd character (starting from 0th) from the out character (or the 4th character) to the safe character (the 4th character) is separated by the 4th character string. Since it is a character string that has been converted to a character string that is converted to a character string that is an odd-numbered character string that has the fourth character string as a boundary (the first is the 0th), it is separated by the fifth character as a boundary. If the character string is "a fixed character string, convert it to a character string corresponding to the character string (for example, if it is "OUT1", convert it to a newline)", "If the above-mentioned processing cannot be performed, characters that can be treated as a character code If it is a string, it is converted to the character corresponding to the character code (for example, it is converted to a comma if it is "2C"), "If none of the above processing is possible, a character string indicating that (for example, an empty character string, 〓 Convert to symbol)”.
)

This embodiment can be performed by a routine. (Routines are procedures used in VB.net etc., functions used in C language etc.) This routine converts a character string containing out characters or fourth characters into a character string not containing out characters. Argument of truth value type (hereinafter, this argument is referred to as toDBstyle) that specifies whether or not, and a string type argument that specifies the character string to be converted (hereinafter, this argument is referred to as HStext) , A routine having a character string type argument (hereinafter, this argument is referred to as err) that specifies a value to be returned when the routine fails in processing, and a return value is a character string type routine. The routine is what the fourth character string is, what the out character is, and what the out character and the fourth character string should be converted to (what character string should be converted to the out character). , The fifth character string is set. (For example, the first character string is the character string “OUT1”, the second character, the third character, and the fourth character are the hexadecimal numbers in which the character codes that mean the respective characters are capitalized. Converted to the written character string.The fifth character string is "-". That is, the out character (including the fourth character) is O, U, T, 1, 2, 3, 4, 5, 6, 7,8,9,0,A,B,C,D,E,F,-Converted to a character string that uses 0 or more of 0 or more characters, and the converted and non-converted parts Are separated by the fourth character.)

FIG. 2 is a flowchart showing a procedure in which the information processing apparatus according to the first embodiment executes the processing described in the first embodiment. The CPU 11 of the information processing device 1 executes the following processing based on the program 12P. Based on the argument toDBstyle, the CPU 11 determines whether the argument HStext is “convert a character string having an OUT character (including the fourth character) into a character string consisting of only safe characters” or vice versa (step S201). .. In the following description, the first character is a line break, the second character is a comma (,), the third character string is a slash (/), the fourth character is an equal sign (=), and the fifth character is a minus. The case of the symbol (-) will be described as an example. The character string err is, for example, an empty character string.

The case of "converting the out character (including the fourth character) into a character string including only safe characters" (step S201: YES) will be described. Here, "(,,゜Д゜)R(=゜ω゜)ノR(=,=;)/" (where R is a line feed) is assigned to HStext, and this is converted to a character string consisting of safe characters only. A case will be described as an example. See FIG. Based on the program 12P, the CPU 11 determines what to convert the out character (including the fourth character) to (step S301), and determines the out character (the fourth character string) existing in HStext (the character string S203A). Character) is converted to a safe character, the fourth character is inserted at the boundary between the converted portion and the non-converted portion, and the portion in which the fourth character is two consecutive is replaced with one fifth character string. Create a column S203B (step S302), reverse the truth of toDBstyle, and substitute the character string S203B into HStext to check whether the character string created by the step is correct. It is confirmed whether the character string S203A is created by calling (step S303). The CPU 11 stores in the RAM 13 or the storage unit 12 the character string S203A if the same character string as the character string S203A is created in step S303, otherwise stores the character string err, and ends the processing.

A case of "converting a character string including only safe characters into a character string having an out character (including the fourth character)" (step S201: NO) will be described. Here, "(=2C-2C=゜Д゜)=OUT1=(=3D=゜ω゜)no=OUT1=(=3D-2C-3D=;)=2F=" is substituted into HStext, and this is , The case of converting to a character string including an out character will be described as an example. See FIG. Based on the program 12, the CPU 11 divides the designated character string (character string 401) into an array with the fourth character as a boundary (array 402). An odd-numbered element (table 403A) in which the first element of the array 402 is the 0th element is divided into arrays at the fifth character string (array 403B) (the blank indicates that the element exists). For each element of the array 403B, "if it can be converted to a character corresponding to the character code by considering it as a hexadecimal character code, do that". If it is not possible to do any of the above, a character string indicating that (for example, an empty character string) (for example, 〓 symbol) The process of “converting to” is performed in this order (array 403C). A character string is created by connecting each element of the array 403C, and the odd-numbered element of the array 402 is replaced by the character string (array 404). A character string 405 is created by connecting the elements of the array 404. The CPU 11 stores the created character string in the RAM 13 or the storage unit 12, and ends the process.

The sixth aspect will be described.
The condition A is, for example, “any one of the first character, the second character, the third character, and the fourth character”, the condition B is “the fourth character”, and the C times are It is conceivable that “the number of times is an even number”, the number of times determined by the value of C is “half the number of times of C”, and condition D is “the fifth character”. This is an example, and other conditions may be set.

Based on the program 12P, the CPU 11 identifies a portion that satisfies the condition A existing in the character string to be converted, determines what that portion is a character string that does not satisfy the condition A, and determines according to the determination. A process of converting the part is performed, and a process of inserting a character string satisfying the condition B at the boundary between the processed part and the other part is performed. Times) a continuous part is specified, the part is converted into a character string that satisfies the condition D (continuous times are determined by the value of C), and the character string created by these processes is It is stored in the RAM 13 or the storage unit 12.

<Second Embodiment>
In the second embodiment, the database is read, edited, and part or all of the writing process is executed. FIG. 8 is a block diagram showing the configuration of the information processing system according to this embodiment. The information processing system includes an information processing device (first information processing device) 1 and a second information processing device 2. The configuration of the information processing device 1 is similar to that of the first embodiment. As shown in FIG. 8, the information processing device 1 and the second information processing device 2 are connected to the communication network N.
However, the communication network N may be connected to three or more information processing devices.

The second information processing device 2 is a computer such as a server device, a personal computer, or a smartphone. The second information processing device 2 includes at least one of a CPU 21, a storage unit 22, a RAM 23, an input unit 24, a display unit 25, a communication unit 26, and a drive unit 27. The CPU 21, the storage unit 22, the RAM 23, the input unit 24, the display unit 25, the communication unit 26, and the drive unit 27 of the second information processing apparatus 2 have the same configuration as the CPU 11, the storage unit 12, the RAM 13, and the input unit 14 of the information processing apparatus 1. The display unit 15, the communication unit 16, and the drive unit 17 are the same as those in FIG.
Since the recording medium 20 is similar to the recording medium 10, the description is omitted for brevity.
However, when three or more information processing devices are connected, what is provided by the third and subsequent information processing devices is the same as that provided by the second information processing device 2.

FIG. 5 is a diagram showing the configuration of the database processing unit according to the present embodiment.
The reading unit 501 reads and acquires information indicating the location of the database (for example, the storage unit 22 of the second information processing apparatus 2) (for example, the recording medium 10 set in the second information processing apparatus 2) or the database. At least one of receiving the received data, storing the information indicating the location of the database in the stream storage unit 511, and storing the data read and acquired from the database in the text storage unit 512. To do. (The CPU 11 stores, based on the program 12P, information indicating a location of a predetermined location (for example, the storage unit 12) (for example, the storage unit 22) (for example, the recording medium 10) (for example, the recording medium 20) or the predetermined location. At least one of the information obtained by reading the data is created and the information is stored in the storage unit 12 or the RAM 13.)
The stream storage unit 511 stores the information indicating the location of the database by the reading unit 501. At this time, not only the information indicating the location of the database but also the information indicating another location (for example, the location where the data deleted from the database should be stored) may be stored.
The text storage unit 512 stores the data read and acquired from the database. At this time, information used for editing and using the database (for example, when saving the database as a flat file database, that is, plain text, the character indicating the column boundary, the character indicating the record boundary, and the key string It may be stored by including information indicating whether or not there is information necessary for defining the meaning of the column.
The change storage unit 513 stores the changes to be made to the database. (For example, change the data of the part whose column is "name" in the record whose key string is 1 to "DEF", and delete the record whose key string is 2).
The changing unit 502 writes, in the change storage unit 513, a change to be made to the database (for example, “change the information corresponding to the column “name” of the record whose key string is 2 to “Homura””) 503. Writes erasure to be applied to the database in the change storage unit 513.
The writing unit 521 executes at least one of writing in a database and creating data to be written in the database.
The acquisition unit 522 refers to at least one of the text storage unit 512 and the change storage unit 513, and specifies what is currently written in the database. At this time, if the contents of the text storage unit 512 and the change storage unit 513 are inconsistent, the change storage unit 513 is prioritized. (For example, it is stored in the text storage unit 512 that the column “name” of the record having the key string of 2 is “Madoka”, and the change storage unit 513 stores “the record of the key string being 2”). , If the content of the column “Name” should be “Sayaka” is written, and if the data in the column “Name” of key column 2 is specified, the answer is “Sayaka”)

(
Modification: The stream storage unit 511 or the text storage unit 512 may not exist. In this case, the reading unit 501, the writing unit 521, and the acquisition unit 522 do not refer to the stream storage unit 511 or the text storage unit 512, whichever does not exist.
)

The database processing unit is a data collection (array, associative array, structure, variable of user-defined type, class, union, etc.) that can have zero or more values. An instance is included. A data aggregate such as a structure includes zero or more members that are variables.When a variable in a data aggregate is called an element, the member is an element. The relationship of 0 or more members may be defined with respect to each other such as the order, and data can be treated as 0 or more. (Eg class)

When the database processing unit is a class (instance of), the reading unit 501, the changing unit 502, the deleting unit 503, the writing unit 521, and the acquiring unit 522 are routines, and are the stream storage unit 511, the text storage unit 512, and the change storage. The part 513 is a variable that cannot be directly referenced or changed from outside the database processing part. (So-called private variable)

<Third Embodiment>
In this embodiment, the reading unit 501 is executed. The hardware configuration of this embodiment is the same as that of the second embodiment.

FIG. 9 is a flowchart showing a procedure of a process in which the information processing apparatus according to the third embodiment executes the reading unit 501. The procedure of the process illustrated in FIG. 9 is an example of a process in which the CPU 11 executes the reading unit 501. The CPU 11 of the information processing device 1 stores information indicating the location of the database or null in the RAM 13 or the storage unit 12 (step S901). The CPU 11 determines whether the content stored in step S901 is null (step S902), and if not null (step S902: YES), the data existing in the location indicated by the content stored in step S901. Is read and the content is stored in the RAM 13 or the storage unit 12 (step S906). When the determination is null (step S902: YES), the designated data is stored in the RAM 13 or the storage unit 12. (For example, when the content to be stored in step S901 is null, predetermined data is stored in the RAM 13 or the storage unit 12.)

The reading unit 501 can be a routine. The routine includes an argument HSstream indicating information (may be null) indicating a location where the database exists, an argument HSstreamdelete indicating a location (which may be null) at which data deleted from the database should be stored, database Data HStext_DBstyle read from, the argument HSkugiri that shows what the column boundaries are in the flat file database, the argument keycolumn that shows which columns in the database are the key columns, and what the columns mean It has an argument titlerow indicating which row is to be executed and an argument startrow indicating which row is the starting row of the record.
(The CPU 11 stores the argument of the routine in the RAM 13 or the storage unit 12 based on the program 12P. At this time, the CPU 11 performs the predetermined processing based on the program 12P. May be stored)) (Variation: It may be a routine that has an argument indicating what the line/record boundary in the flat file database is.)

HStext_DBstyle is given as a flat file database in which the first specific character (for example, a line feed) is a line/record boundary and the second specific character (for example, a comma) is a column boundary, that is, a character string. Therefore, at least in the case of "the first specific character or the second specific character in the field", the character existing in the field does not use the character (for example, described in Embodiment 1). Form). (For example, if you want to express the character string "1,(,,゜Д゜)" on a certain line, write "1,(=2C-2C=゜Д゜)". If "1,(= ",, ゜Д゜)" is not treated as a character string that fits in one field. "(,,゜Д゜)")

<<When HSstream is not null>>
In step S902, since it is determined as NO, HSstream is stored in the stream storage unit 511. The text storage unit 512 stores data read based on the data stored in the stream storage unit 511. At this time, the data to be read is described as a flat file database, that is, a text file, but it may be in another form.

However, the text storage unit 512 will be described as a specific form (here, it will be described as a character string type jagged array. Although the text storage unit 512 may be described as storing a character string type jagged array, other forms). It may be), so it is necessary to convert to this form. Here, it is assumed that the data read based on the data stored in the stream storage unit 511 is a text format and the text storage unit 512 is a character string type jug array.

In the text read based on the data stored in the stream storage unit 511, HSkugiri is a column boundary, and a specific character (for example, a line feed) is a record/line boundary (a record/line of a flat file database. Sometimes described as a line break, but it may be in any other form).

FIG. 14 is a flowchart showing a procedure of processing executed by the reading unit 501.
The CPU 11 of the information processing device 1 exists in the data read from the storage unit 12 or the RAM 13 or the storage unit 22 or the RAM 23 based on the data (for example, FIG. 1401) stored in the stream storage unit 511 based on the program 12P. Divide into a first array with a specific character (for example, a line feed) as a boundary (the result is, for example, Table 1402), and divide each element into a second array with HSkugiri existing in each element of the first array as a boundary. (Jug array) is divided (the result is, for example, table 1403), and the second array is stored in the RAM 13 or the storage unit 12.

In the flat file database, the first specific character (for example, a line feed) is a line/record boundary, and the second specific character (for example, a comma) is a column boundary. Therefore, if there is at least "the first specific character or the second specific character in the field", the character is expressed without using the character. Therefore, before creating the second array and storing it in the text storage unit 512, it is necessary to convert the portion expressed without using the character into the character. The procedure is as described in the first embodiment. For example, when "(=2C-2C=°Д°)" is stored in a certain element, it is converted into "(,,°Д°)" by the procedure described in the first embodiment.

<<When HSstream is null>>
In step S902, since it is determined to be YES, the text storage unit 512 stores the HStext_DBstyle converted into a jagged array. Here, HStext_DBstyle is described as a character string, but other forms are also possible.

The text assigned to HStext_DBstyle can be explained assuming that HSkugiri is a column boundary and a specific character (for example, a line break) is a record/line boundary (a record/line boundary in a flat file database is a line break). There may be other forms).

FIG. 14 is a flowchart showing a procedure of processing executed by the reading unit 501.
Based on the program 12P, the CPU 11 of the information processing device 1 stores a specific character (for example, FIG. 1401) stored in HStext_DBstyle or stored in the data (stored in the RAM 13 or the storage unit 12 or the RAM 23 or the storage unit 22) (for example, FIG. 1401). For example, a line feed) is used as a boundary to divide into a first array (the result is, for example, Table 1402), and each element is divided into a second array (jag array) with HSkugiri existing in each element of the first array as a boundary. The data is divided (the result is, for example, a table 1402) and the second array is stored in the RAM 13 or the storage unit 12. )

In the flat file database, the first specific character (for example, a line feed) is a line/record boundary, and the second specific character (for example, a comma) is a column boundary. Therefore, if there is at least "the first specific character or the second specific character in the field", the character is expressed without using the character. Therefore, before creating the second array and storing it in the text storage unit 512, it is necessary to convert the portion expressed without using the character into the character. The procedure is as described in the first embodiment. For example, when "(=2C-2C=°Д°)" is stored in a certain element, it is converted into "(,,°Д°)" by the procedure described in the first embodiment.

<Embodiment 4>
In this embodiment, the form of the stream storage unit 511 will be described. The hardware configuration of this embodiment is the same as that of the second embodiment.

FIG. 15 is a diagram showing the stream storage unit 511. The database storage unit 1501 stores information indicating the location of the database. The deleted data storage unit 1502 stores information indicating a location where the deleted data should be stored. In both cases, the data type is, for example, a variable of System.IO.stream type.

The third embodiment will be supplemented. HSstream is stored in the database storage unit and HSstream delete is stored in the deleted data storage unit.

Based on the program 12P, the CPU 11 secures at least one of the part used as the database storage part 1501 and the part used as the deleted data storage part 1502 in the storage part 12 or the RAM 13.

<Embodiment 5>
In this embodiment, the form of the text storage unit 512 will be described. The hardware configuration of this embodiment is the same as that of the second embodiment.

The database storage unit 1601 stores data read from a database, for example. For example, a string type jug array. (In the present specification, the "array storing the array" in the database storage unit 1601 may be described as a row, and the array stored in the "array storing the array" may be described as a column. At this time, the first row is (The 0th row and the first column may be described as the 0th column.)

The line boundary storage unit 1602 stores what character is a line/record boundary when handling a flat file database. For example, a string type variable or constant.

The column boundary storage unit 1603 stores what character is a boundary between columns when handling a flat file database. For example, a string type variable or constant.

The key column position storage unit 1604 stores which column in the database storage unit 1601 is a key column. For example, an integer variable or constant.

The title line storage unit 1605 stores which line in the database storage unit 1601 is a title line. The title row is a row that defines which column (column) means what for columns other than key columns. For example, an integer variable or constant.

The record start row storage unit 1606 stores which row and subsequent rows in the database storage unit 1601 are records. For example, an integer variable or constant. In the database, the number of records may be 0. For example, “0” is stored in the title line storage unit, “1” is stored in the record start line storage unit, and the database storage unit is stored. If the stored jug array is one line (the first line is counted as the 0th line, so only the 0th line exists), the title line exists, but no record exists (this specification). In the book, the line where the record is stored is sometimes referred to as the "data line").

The third embodiment will be supplemented. The data read based on the information indicated by HStext_DBstyle or HSstream is stored in the database storage unit, HSkugiri is the column boundary storage unit, keycolumn is the key column position storage unit, titlerow is the title row storage unit, and startrow is the record start row storage unit. To be done. In the third embodiment, a character indicating a line boundary is not specified, and the line boundary storage unit stores a character (for example, a line feed) defined by the program 12P. (Modification: When a routine having an argument indicating what is the line/record boundary in the flat file database is used, it is assigned to the argument indicating what the line/record boundary is in the flat file database. Stored data in the row boundary storage section)

(
Modification: The title row storage unit 1605 may store which column has what meaning (for example, associative array that returns integer type with character string type as key). In this case, the database storage unit 1601 may not have a title line.
)

Based on the program 12P, the CPU 11 stores a database storage unit 1601, a row boundary storage unit 1602, a column boundary storage unit 1603, a key column position storage unit 1604, a title row storage unit in a predetermined location (for example, the storage unit 12 or the RAM 13). A portion for storing at least one of 1605 and the record start row storage unit 1606 is secured.
0

<Sixth Embodiment>
In this embodiment, the writing unit 521 is executed. The hardware configuration of this embodiment is the same as that of the second embodiment.

In this embodiment, the data stored in the database, which has been changed as stored in the change storage unit 513, is written in a predetermined location (for example, the storage unit 12 or the RAM 13).

FIG. 11 is a flowchart showing a procedure of processing in which the information processing apparatus according to this embodiment executes the writing unit 521.
FIG. 12 is a diagram for explaining an example of processing performed by the information processing apparatus according to the present embodiment. In FIG. 12, the top row is the 0th row, the leftmost column is the 0th column, the title row is the 0th row (0 is stored in the title row storage unit 1605), and the data row is 1. The description will be made assuming that the key column is the 0th column (0 is stored in the key column position storage unit 1604) from the column onward (1 is stored in the record start row storage unit 1606).

Based on the program 12P, the CPU 11 determines whether or not null is stored in the stream storage unit 511 (step S1101). If null is stored in the stream storage unit 511 (step S1101: YES), If the data stored in the text storage unit 512 is the data to be changed (step S1102A), and null is not stored in the stream storage unit 511 (step S1101: NO), it is stored in the stream storage unit 511. The data read based on "information indicating the location of the database" is set as the data to be changed (step S1102B). Table 1201 shows an example of the data to be changed.

Based on the program 12P, the CPU 11 sets the number of columns of the title row (row located at the position defined by the title row storage unit 1605) of the data to be changed to the maximum number of columns of other rows ( Hereinafter, the same number as the "maximum number of columns" is set (step S1103).
In the case of the example described with reference to FIG. 12, this step is performed on the table 1201, but in the case of this example, the number of columns in the title row is the same as the maximum number of columns, so it does not change. (In most cases, the maximum number of columns does not change in step 1203. In the present invention, the number of columns in the title row is controlled so as not to be less than the number of columns in other columns, but this is not the case due to a defect. In this case, it is corrected by step S1103)

Based on the program 12P, the CPU 11 adds, to the title line of the change target data, data that does not exist in the title line of the change target data but exists in the change storage unit 513 (step S1104).
In the case of the example described with reference to FIG. 12, a table 1202 is an example of data existing in the change storage unit 513. In this example,
"Write 1C to the field of the column whose title row is C in the record whose key column is 1."
"Write 3A in the field of the column whose title row is A in the record whose key column is 3"
"Write 5A in the field of the column whose title row is A in the record whose key column is 5"
"Write 7A in the field of the column whose title row is A in the record whose key column is 7"
The information is stored. That is, the data “A, B, C” is required in the “column that is not the key column” of the title row, but in the case of the table 1201, the data “C” does not exist in the title row. Based on the program 12P, the CPU 11 identifies data (here, C) that does not exist in the title line and exists as the title of the change storage unit 513, and sets the data in the title line of the data to be changed. to add. Table 1204 shows an example of the result.

Based on the program 12P, the CPU 11 writes the contents stored in the change storage unit into the change target data (step S1105).
In the case of the example described with reference to FIG. 12, since the data to be changed is written in the records (rows) whose key columns are 1, 3, 5, and 7, the number of columns in the corresponding row is the number of columns in the title row. Do the same. Table 1205 shows an example of the result.
Next, the CPU 11 writes an appropriate value in an appropriate position based on the program 12P. In the case of the example described in FIG. 12,
The process of writing 1C to the field of the column whose title row is C in the record whose key string is 1.
The process of writing 3A in the field of the column whose title row is A in the record whose key string is 3.
The process of writing 5A in the field of the column whose title row is A in the record whose key string is 5.
The process of writing 7A in the field of the column whose title row is A in the record whose key string is 7.
To execute. As a result, examples of tails are shown in Table 1206.

Based on the program 12P, the CPU 11 executes a process of dividing the data to be changed into a line to be deleted and a line other than that (step S1106).
The row to be deleted is the row stored as the “record to be deleted” in the change storage unit 513. An example is shown in Table 1203. In this example, the change storage unit 513 stores the information “Delete record with key string 4”. The data to be changed may be classified into the lines to be deleted only after the line designated in the record start line storage unit 1606.
In the case of the example described in FIG. 12, the record (row) whose key column is 4 is the row to be deleted, so only the data to be deleted (Table 1208) and the other rows are to be deleted. The data (Table 1207) is extracted.
Hereinafter, in the case of notating “the second data to be changed”, “the data extracted only from the lines other than the line to be deleted” created in step S1106 (in the case of the example illustrated in FIG. 12, the table 1207). ).
Hereinafter, in the case of notating “the second data to be deleted”, “the data obtained by extracting only the lines to be deleted” created in step S1106 (in the case of the example illustrated in FIG. 12, table 1208) Refers to.

The CPU 11 converts the second modification target data and the second deletion target data into a character string based on the program 12P (step S1107).
Since the character string created in this step is used as a flat file database, the characters stored in the row boundary storage unit 1602 are used as the line/record boundaries, and the characters stored in the column boundary storage unit 1603 are used as the column boundaries. It
Therefore, if at least a field has a character same as the character stored in the row boundary storage unit 1602 or a character stored in the column boundary storage unit 1603, the corresponding character is directly converted into a character string when the database is processed. A malfunction occurs (for example, when “,” is stored in the column boundary storage unit 1603 and “(,,°Д°)” is stored in the field, “,,” existing in the field is replaced with another Must be expressed by form).
Therefore, the CPU 11 converts the character string of the field into an appropriate form based on the program 12P. The contents of the conversion process are as described in the first embodiment.
In the case of the example described with reference to FIG. 12 (here, “,” is stored in the column boundary storage unit 1603 and a line break is stored in the row boundary storage unit 1602), the second change target A character string is created by concatenating the data and the array that is each element of the second data to be deleted (both are jagged arrays) with the character stored in the column boundary storage unit 1603 being sandwiched, and the character string is used as an element. And a character string that is each element of the one-dimensional array is connected with the characters stored in the row boundary storage unit 1602 interposed therebetween. That is, the second modification target data is a character string as shown in the character string 1209, and the second deletion target data is a character string as shown in the character string 1210.
Hereinafter, the character string created from the second change target data will be referred to as a “surviving character string”, and the character string created from the second delete target data will be referred to as a “delete character string”.

Based on the program 12P, the CPU 11 stores, for example, the remaining character string in the RAM 13 or the storage unit 12 (step S1108). However, step S1108 may be executed after steps S1109 and S1110.

Based on the program 12P, the CPU 11 determines whether or not null is stored in the stream storage unit 511 (step S1108), and if null is stored in the stream storage unit 511 (step S1108: YES), , At least one of the remaining character string and the deleted character string is stored in the location indicated by the stream storage unit 511 (which stores information indicating the location of the database) (stored in the RAM 13 or the storage unit 12, the RAM 23 or the storage unit 22). ).
The details are as follows.
It is determined whether or not null is stored in the database storage unit 1501 (step S1108). If null is stored in the database storage unit 1501 (step S1108: YES), the survival character string is stored in the database storage unit 1501. The data is stored in the location indicated by (store information indicating location of database) (stored in RAM 13 or storage unit 12 or RAM 23 or storage unit 22).
It is determined whether or not null is stored in the deleted data storage unit 1502 (step S1108). If null is stored in the deleted data storage unit 1502 (step S1108: YES), the deleted character string is deleted. The data is stored in the location indicated by the storage unit 1502 (stores information indicating the location where the database exists) (stored in the RAM 13 or the storage unit 12, or the RAM 23 or the storage unit 22).

(
Modification:
(If data already exists at the location indicated by the deleted data storage unit 1502, the data may be added or overwritten.)

This embodiment can be performed by a routine. The routine has no arguments, refers to the stream storage unit 511 (may include information existing at the position indicated by the stream storage unit 511), the text storage unit 512, and the change storage unit 513, and operates based on the program 12P. Is executed by the CPU 11. The return value is, for example, a data set (for example, a class) in which the data stored in the stream storage unit 511 and the remaining character string are stored.

<Embodiment 7>
In the present embodiment, the changing unit 502 is executed. The hardware configuration of this embodiment is the same as that of the second embodiment.

The present embodiment stores information indicating what should be written in a field that is a column of a record having a key of a database in a predetermined location (for example, the storage unit 12 or the RAM 13). Is.

The changing unit 502 accepts designation of a record and a column to write data and a designation of data to be written (for example, a character string), and changes the information indicating that the database should be changed according to the designation, the change storage unit 513 (update storage unit 1310). Write in. (Modification: The database is changed as specified.)

FIG. 17 is a flowchart showing a procedure of processing in which the information processing apparatus according to the seventh embodiment executes the update storage unit 1310 which is a part of the changing unit 502.

The CPU 11 confirms whether null is stored in the update storage unit 1301 based on the program 12P (step S1701). If null is stored in the update storage unit 1301 (step S1701: YES), the update storage is stored. The unit 1301 is a data aggregate having 0 elements (for example, an associative array).

Based on the program 12P, the CPU 11 confirms whether the same key as the key to be written in the update storage unit 1301 already exists in the update storage unit 1301 (step S1703), and if so (step S1703: YES) Makes the value corresponding to the same key as the key to be written, which exists in the update storage unit 1301, the second data set (for example, associative array). If not (step S1703: NO), a data aggregate with the number of elements of 0 (for example, an associative array) is created, and this is used as the second data aggregate.
An example will be described in which it is desired to store in the update storage unit 1301 information that means “change the value of the field in which the column of the record whose key string is 11 is D to 11D”. If a key “11” exists in the update storage unit 1301, the value corresponding to the key is set as the second data set, and in other cases, a data set having 0 elements is created. Be a second data set.

The second data set is, for example, “an associative array that returns a character string with a character string as a key”, and the data set stored in the update storage unit 1301 is, for example, “a second data set with a numerical value as a key. An associative array that returns the body."

The CPU 11 writes a combination of columns and fields in the second data set based on the program 12P. (Step S1706)
An example will be described in which it is desired to store in the update storage unit 1301 information that means “change the value of the field in which the column of the record whose key string is 11 is D to 11D”. When "D" exists in the key of the second data set, the value corresponding to the key is changed to "11D". When "D" does not exist in the key of the second data set, a combination of "D" as the key and "11D" as the value is added to the key-value combination of the second data set. To do.

The CPU 11 adds the second data aggregate to the update storage unit 1301 (stores in the RAM 13 or the storage unit 12) based on the program 12P.
An example will be described in which it is desired to store in the update storage unit 1301 information that means “change the value of the field in which the column of the record whose key string is 11 is D to 11D”. When “11” exists in the key of the update storage unit 1301, the value corresponding to the key is changed to the second data set. When “11” does not exist in the key of the update storage unit 1301, a combination having “11” as the key and the value of the second data aggregate is added to the combination of the key and the value in the update storage unit 1301. ..

(
Modification:
In the present embodiment, the case of using the associative array has been illustrated, but a data aggregate that is not an associative array may be used. For example, two lists are created, and the one that corresponds to the key of the associative array in the first list and the one that corresponds to the value of the associative array in the second list are stored.
)

(
Modification:
This embodiment is to change the update storage unit 1301, and by combining it with other embodiments, the contents of the database can be changed via the update storage unit 1301. Alternatively, the database may be directly changed.
)

The changing unit 502 can be performed by a routine. The routine has an argument code (for example, integer type) indicating a key of a record to be written, an argument title (for example, character string type) indicating a column to be written in the record, and what to write in the column of the record. Has an argument data (for example, a character string type) indicating. (For example, if you want to write 1A to the field whose column is A in the record whose key string is 1, substitute 1 for code, A for title, and 1A for data.) A value that returns the correctness of writing may be used as the return value.

Based on the program 12P, the CPU 11 confirms whether the update storage unit 1301 is null (step S1701). If the update storage unit 1301 is null (step S1701: YES), the update storage unit 1301 is set to 0. Assume that it is a data set having a number of keys (for example, an associative array whose value is an associative array that returns a character string from a character string with an integer key).

Based on the program 12P, the CPU 11 determines whether the key of the update storage unit 1301 is the same as the code (step S1703), and the key of the update storage unit 1301 is the same as the code (step S1703: In the case of YES), the value corresponding to the key is set as the second data set (step S1705). In other cases, a data set having 0 keys is created, and this is set as the second data set. (Step S1704).
Based on the program 12P, the CPU 11 writes title and data as a key and value combination of the second data set (if the same key as title already exists, the value corresponding to title is data. (Step S1706).

Based on the program 12P, the CPU 11 writes in the update storage unit 1301 a key/value combination in which code is a key and the second data aggregate is a value. (If the same key as code already exists as a key, change the value corresponding to code to the second data set).

<Embodiment 8>
In this embodiment, the form of the change storage unit 513 will be described. The hardware configuration of this embodiment is the same as that of the second embodiment.

The present embodiment stores what key should be written in what column in the database and what key should be deleted in the database at a predetermined location (for example, the storage unit 12 or the RAM 13). Is.

FIG. 13 is a diagram showing an example of the change storage unit 513 and the data stored in the change storage unit 513.

The update storage unit 1310 stores a change to be made to the database (in the present embodiment, when it is referred to as a change, it includes addition of new data unless otherwise specified). The data type is, for example, an associative array that returns an "associative array that returns a character string type with a character string type as a key" using "integer type" as a key.

The deletion storage unit 1350 stores the deletion to be performed on the database. The data type is a data collection such as an integer type list or collection.
In the example shown in FIG. 13, it means “delete the records whose key strings are 4 and 5”.

The key 1311 is a key of the update storage unit 1310 (associative array).
In the example shown in FIG. 13, since the update storage unit 1310 is an associative array having keys 1, 3, and 7, it is stored that the record whose key string is 1, 3, and 7 in the database should be changed. Has been done.

The value 1312 is a value corresponding to each key of the update storage unit 1310 (associative array), and the data type is, for example, an associative array that returns a character string type from a character string type.
In the example shown in FIG. 13, the value returned with "1" as a key is an associative array that returns "A" to "1AA" and "C" to "1CC". This is "Set the value of the field whose column is AA to 1AA in the record whose key string is 1""Set the value of the field whose column is CC to 1CC in the record whose key string is 1" meaning. Values that are returned as keys 3 and 7 are also stored in the same manner.

The associative array 1320 is an associative array that is a value to be exercised by each key of the update storage unit 1310 (associative array). A key 1321 is a key of the associative array 1320, and a value 1322 is a value of the associative array 1320.

Based on the program 12P, the CPU 11 secures a portion that stores at least one of the update storage unit 1310 and the deletion storage unit 1350 in a predetermined location (for example, the storage unit 12 or the RAM 13).

(
Modification:
In the present embodiment, an associative array that returns a second associative array (hereinafter “data 2”) using an integer type (hereinafter “data 1”) as a key, and the second associative array are character strings (hereinafter “data”). 2A”) is used as a key to exemplify the case of an associative array that returns a character string (hereinafter, “data 2B”), but a data aggregate that does not rely on this may be used.
)

<Embodiment 9>
In the present embodiment, the erasing unit 503 is executed. The hardware configuration of this embodiment is the same as that of the second embodiment.

In the present embodiment, the specification of the key string of the record to be deleted is received from the database, and the deletion storage unit 1350 stores information indicating that the key string should be deleted.

The CPU 11 confirms whether null is stored in the deletion storage unit 1350 based on the program 12P (step S1801). If null is stored in the deletion storage unit 1350 (step S1801: YES), the deletion storage unit 1350 is set as a data aggregate having zero stored keys (step S1802).
The deletion storage unit 1350 is a data aggregate such as a list and a collection.

Based on the program 12P, the CPU 11 confirms whether the same data as the key to be written in the deletion storage unit 1350 exists in the deletion storage unit 1350 (step S1803). If the same data as the key to be written to the deletion storage unit 1350 does not exist in the deletion storage unit 1350 (step S1803: NO), the key to be written to the deletion storage unit 1350 is written to the deletion storage unit 1350 (RAM 13 or storage). (Stored in part 12).
An example will be described in which the information “delete the record whose key string is 13” is written in the deletion storage unit 1350. If the value “13” is not stored in the deletion storage unit, the value “13” is stored in the deletion storage unit 1350.

<Embodiment 10>
In this embodiment, the acquisition unit 522 is executed. The hardware configuration of this embodiment is the same as that of the second embodiment.

In the present embodiment, the change storage unit 513 is searched and the text storage unit 512 is searched. If inconsistent data is recorded as a result of the search, the change storage unit 513 is given priority. (For example, when searching for a “field in which the column of the record whose key string is 1 is C”, “1C” is stored in the change storage unit 513 and “1CC” is stored in the text storage unit 512. If so, “1C” has priority.

In the present embodiment, the designation of the key and the column is accepted, and the data existing in the designated column of the record having the designated key is returned.
FIG. 21 is a flowchart showing a procedure in which the information processing apparatus according to the present embodiment searches for data in at least one of the change storage unit 513 and the text storage unit 512.

A procedure for searching the change storage unit 513 will be described.
Based on the program 12P, the CPU 11 determines whether the update storage unit 1310 has a key to be searched (step S2101), and the update storage unit 1310 has a key to be searched (step S2101: If YES, the value corresponding to the key stored in the update storage unit 1310 is acquired (step S2102). (For example, to obtain the data of the record having the key “16”, it is determined in step S2101 whether the key “16” exists in the update storage unit 1310. If the key exists, In step S2102, the value corresponding to the key is acquired from the update storage unit 1310)

Based on the program 12P, the CPU 11 determines whether or not the column to be searched exists in the key of the data acquired in step S2102 (step S2103), and the key of the data acquired in step S2102 is searched for. If the column to be attempted exists (step S2103: YES), the value corresponding to the key of the data acquired in step S2102 is stored in the storage unit 12 or the RAM 13 (step S2104), and the process ends. (For example, if you want to obtain the data in the column "D", the key of the data obtained in step S2102 is "D", and the key of the data obtained in step S2102 is "D". If it exists, the value corresponding to the key is stored in the storage unit 12 or the RAM 13.) There is no column to be searched for in the key of the data acquired in step S2102 (step S2103: NO). In this case, the procedure moves to the procedure for searching from the text storage unit 512 (step S2111 and thereafter).
In step S2104, if the corresponding key exists in the deletion storage unit 1350, the operation includes an operation (not shown) of storing information indicating that the corresponding data does not exist in the storage unit 12 or the RAM 13.

A procedure for searching the text storage unit 512 will be described. This procedure is performed when the key to be searched does not exist in the update storage unit 1310 (step S2101: NO).
Based on the program 12P, the CPU 11 searches the key string of the text storage unit 512, identifies the position where the key to be searched exists in the key string (step S2111), and tries to search in step S2111. It is determined whether or not the position of the record existing in the key string can be specified by the key (step S2112), and when the position of the record existing in the key string of the key to be searched cannot be specified in the step S2111 (step S2111). In S2112: NO, information indicating that the corresponding data does not exist is stored in the storage unit 12 or the RAM 13 (step S2113), and the process ends.

In step S2111, if the position of the record in which the key to be searched exists in the key string can be specified (step S2112: YES), the title line of the text storage unit 512 (the title line excludes the key string). A row is searched for a row that defines which column means what column), and specifies the position where the column to be searched exists (step S2114). In step S2114, it is determined whether the position of the column to be searched can be specified (step S2115), and if the position of the column to be searched cannot be specified in step S2114 (step S2115: NO), Information indicating that the corresponding data does not exist is stored in the storage unit 12 or the RAM 13 (step S2113), and the process ends.
If the position of the column to be searched can be specified in step S2115, the information existing in the field in the column specified in step S2114 of the record specified in step S2111 is stored in the storage unit 12 or the RAM 13. Remember. If this is not possible, information indicating that the corresponding data does not exist is stored in the storage unit 12 or the RAM 13 (step S2117). The process ends.

An example of step S2111 will be described. Suppose there are columns with key columns 1, 2, and 3 in the text storage. At this time, if a column whose key string is 1, 2, or 3 is searched, step S2112 becomes YES, and otherwise, step S2112 becomes NO.

An example of step S2114 will be described. Suppose data A, B, and C exist in the columns of the title row excluding the key column. At this time, if any of A, B, and C is searched, step S2115 becomes YES, and otherwise, step S2115 becomes NO.

An example of step S2117 will be described. For example, if there is a record corresponding to the third row in step S2111 and a column corresponding to the fifth column in step S2114, the data existing in the fields of the third row and the fifth column of the text storage unit 512 are stored. It is stored in the storage unit 12 or the RAM 13.

This embodiment can be performed by a routine. The routine, for example, as an argument, an argument code (for example, an integer type) indicating a key of a record to be acquired, an argument title (for example, a character string type) indicating a column to be acquired, and a value err returned when data cannot be acquired. (For example, it has a string type) and the return value is, for example, a string type (err is returned when data cannot be acquired, so the return value is the same data type regardless of whether err is a string type) .. (If an error occurs during the operation of the routine and the corresponding data is not found, err is returned, but a different value is returned if an error occurs during the operation of the routine or the applicable data is not found. (In that case, the number of arguments may change, for example, err1 and err2)

The routine checks whether the same thing as code exists in the change storage unit 1310 as a key (step S2101), and if the same thing as code exists in the change storage unit 1310 as a key (step S2101: YES), A value corresponding to the key is acquired as a second data set (eg, associative array) (step S2102). It is confirmed whether the same item as title exists as a key in the second data set (step 2103), and the same item as title exists in the second data set as a key (step S2103: YES). ) Returns the value corresponding to the key of the second aggregate as a return value (stored in the storage unit 12 or the RAM 13), and ends the process (step S2104). If step S2101 is NO, or step S2103 is NO, the process moves to step 2111.
In step 2104, if the same value as the code is stored in the deletion storage unit 1350, err is set as a return value (stored in the storage unit 12 or the RAM 13), and the process ends (not shown).

It is searched whether the same data as code exists in the key string existing in the position corresponding to the record in the text storage unit 512 (step S2111), and the key string existing in the position corresponding to the record in the text storage unit 512 is set to code. It is determined whether the position where the same data exists can be specified (step 2112). If the position where the same data as code exists in the key string existing at the position corresponding to the record cannot be specified (step S2112: NO), , Err as a return value (stored in the storage unit 12 or the RAM 13), and the process ends (step S2113).

If the position where the same data as the code exists in the key string existing at the position corresponding to the record in the text storage unit 512 can be specified (step S2112: YES), the title excluding the key string in the text storage unit 512 In the line, the position where the same data as the title exists is specified (step S2114). It is determined whether or not the position where the same data as title exists in the title row excluding the key column of the text storage unit 512 can be specified (step S2115), and the title row excluding the key column of the text storage unit 512 has the same data as title. If the position where is present could not be specified (step S2115: NO), err is set as a return value (stored in the storage unit 12 or the RAM 13), and the process ends (step S2116).

If the position where the same data as the title exists can be specified in the title row excluding the key string of the text storage unit 512 (step S2115: YES), the column specified in step S2114 of the record specified in step S2111. The data existing in the field is set as a return value (stored in the storage unit 12 or the RAM 13), and the process ends (step S2117).

An error trap may be provided in part or all of the routine, and when an error occurs in the error trap, the return value may be err ().

<Embodiment 11>
Although the embodiment for implementing the changing unit 502 is as described in the seventh embodiment, the embodiment described in the present embodiment may be adopted.

In the case of a database, such as a flat file database, in which a numerical value is converted into a fixed format such as a character string and written, the numerical expression method is different depending on the language, so there is a risk that it will be processed incorrectly by the language. (For example, when registering a numerical value of 23.45, it is written as "23.45" in Japanese and English, but it may be written as "23,45" in Spanish. In this case, the language used for recording the database is If the information processing device that uses a different language is read, the numerical values may be read incorrectly).

FIG. 19 is a diagram showing an example of the changing unit 502. The character string changing unit S1901 is the same as the changing unit 502 in the seventh embodiment.

The operation of the decimal change unit S1902 will be described. The decimal change unit 1902 accepts designation of a record and column to write data and a numeric value to be written, and writes information to the effect that the database should be changed to the change storage unit 513 (update storage unit 1310) as specified. (Modification: The database is changed as specified.)

Based on the program 12P, the CPU 11 rounds the numerical value to be written (hereinafter referred to as X) to 0 (compared to X, closes to 0 (small difference from 0), and sets it as the most X. Change to a value with a smaller difference) (hereinafter referred to as A) and the step of calculating the absolute value of the difference between X and A (hereinafter referred to as B) (step S2001) until B becomes an integer. A step of calculating a value (hereinafter referred to as C) obtained by repeating the process of multiplying B by 10 (step S2002), a step of concatenating A and a symbol meaning a decimal point (for example, period) and C to create a character string Is executed (step S2004), and the character string changing unit 1901 is executed. At this time, the character string to be written is the character string created in step S2004. (Step S2005).
The symbol indicating the decimal point is determined by, for example, the program 12P, and regardless of the language used, the program 12P handles the symbol as the decimal point. The decimal type is desirable as the data type when using a variable that may store a decimal.

An example of the calculation will be shown.
When X=16.705, A=16, B=0.705, C=705, and the character string "16.705" is created. If the process of directly converting X into a character string is performed, the character string may be an inappropriate character string such as "16,705" depending on the language used by the information processing apparatus that executes the program 12P.
When X=-45.6492, A=-45, B=0.6492, C=6492, and the character string "-45.6492" is created. If X is directly converted to a character string, it may be an inappropriate character string such as "-45,6492" depending on the language used by the information processing device that executes the program 12P and the like. ..

The decimal change unit S1902 can be performed by a routine. The routine sets the key of the record to be written as code (eg, integer type), the column to be written as title (eg, string type), and the numerical value to be written in the field as data (eg, decimal type), and the above calculation is performed. Then, the routine described in the seventh embodiment is executed. At this time, code and title are passed as arguments meaning a key and a column, respectively, and the character string to be written in the field is passed as an argument the character string created by the above processing.

The operation of the numerical value changing unit S1903 will be described.
The numerical value changing unit S1903 can be performed by a routine. The routine sets the key of the record to be written as code (eg, integer type), the column to be written as title (eg, string type), and the numerical value to be written in the field as data (eg, floating point type), and data is 10 It is converted to a decimal type (hereinafter referred to as data_dec), and the decimal change unit S1902 is executed with code, title, and data_dic as arguments.

<Remarks>
In this specification, there is a case where an array is handled, but it is not necessarily an array as long as it is a method that can be handled like an array such as a collection or a list.
In this specification, the CPU of the information processing device 1 operates to operate a part or all of the second information processing device 2, but the information processing device 1 and the second information processing device 2 communicate with each other, and the communication content Based on the above, the CPU 21 of the second information processing device 2 may be operated to operate a part or all of the second information processing device 2.
In this specification, there is an expression to read/write data to/from a storage unit or RAM, but data may be read/written to/from a storage medium via a drive unit.
In this specification, there is an expression in which the program is stored in the storage unit, but it is stored in another place (for example, a recording medium) (for example, another information processing device connected via a communication network). May be.
In the present specification, there is an expression of "to character" like "first character", but the portion may be read as "character string".
Although the text storage unit 512 may be described as storing a character string type jagged array, it may be described as a record/line boundary of a flat file database which may be in a different form. However, other forms may be used.
It may be explained that the boundaries of the columns of the flat file database are commas, but other forms may be used.
In this specification, the expression “stream storage unit” may be used, but it is not always necessary to store it as a stream.
Although some hardware configurations are described in this specification, there is no intention that the hardware configurations should be as described above, and any hardware configuration can be used as long as the invention described in this specification can be implemented. It can be configured.
In the present specification, there is a case where a change is made to existing data, and this includes adding new data that does not exist, unless otherwise specified.
In this specification, the fact that data is not stored may be expressed as “null is stored”.
In the present specification, there is an expression that the first object changes the second object, the changed second object is referred to, and the third object is changed. The third object may be changed. For example, instead of the routine changing the data stored in the storage unit or the RAM and referring to the data to change the contents of the database, the routine may change the contents of the database.
An error trap is installed in a part or all of the routines described in this specification, and when an error occurs in the error trap, the return value is a predetermined value that means an error. Good.
In this specification, it may be stated that a predetermined value is returned when an error occurs or the corresponding data is not found. However, when an error occurs and when the corresponding data is not found In this case, a different value may be returned. In that case, the number of arguments of the routine may change.
In this specification, a hardware configuration similar to that of the second embodiment may be similar to that of the first embodiment.
The embodiments disclosed this time are to be considered as illustrative in all points and not restrictive. The scope of the present invention is shown not by the above meaning but by the scope of the claims, and is intended to include meanings equivalent to the scope of the claims and all modifications within the scope. Further, the respective embodiments can be appropriately combined within the range in which the processing content is not inconsistent.

FIG. 3 is a block diagram showing an information processing device. 6 is a flowchart showing a procedure for the information processing apparatus according to the first embodiment to execute the processing described in the first embodiment. 3 is an explanatory diagram of an example of processing performed by the information processing apparatus according to the first embodiment. FIG. 3 is an explanatory diagram of an example of processing performed by the information processing apparatus according to the first embodiment. FIG. FIG. 6 is a diagram showing a configuration of a database processing unit according to the second embodiment. FIG. 3 is a block diagram showing an information processing device. FIG. 3 is a block diagram showing an information processing device. 3 is a block diagram showing the configuration of an information processing system according to Embodiment 2. FIG. 9 is a flowchart showing a procedure of processing in which the information processing apparatus according to the third embodiment executes a reading unit 501. FIG. 3 is a block diagram showing an information processing device. 9 is a flowchart showing a procedure of a process in which the information processing apparatus according to the sixth embodiment executes a writing unit 521. FIG. 16 is a diagram for explaining an example of processing performed by the information processing device according to the sixth embodiment. FIG. 16 is a diagram showing an example of a change storage unit 513 and data stored in the change storage unit 513 according to the eighth embodiment. 9 is a flowchart showing a procedure of processing executed by the reading unit 501 according to the third embodiment. The figure which shows the stream storage part 511 which concerns on Embodiment 4. The figure which shows the text memory|storage part 512 which concerns on Embodiment 5. 20 is a flowchart showing the procedure of a process in which the information processing apparatus according to the seventh embodiment executes an update storage unit 1310 that is a part of the changing unit 502. 10 is a flowchart showing a procedure of processing in which the information processing apparatus according to the seventh embodiment executes a deletion storage unit 1350 which is a part of the changing unit 502. The figure which shows an example of the change part 502 which concerns on Embodiment 11. 23 is a flowchart showing the procedure of processing performed by the information processing apparatus according to the eleventh embodiment. 20 is a flowchart showing a procedure in which the information processing apparatus according to the tenth embodiment searches for data in at least one of the change storage unit 513 and the text storage unit 512.

Claims (46)

A program for managing a flat file database (where the first character is a record boundary and the second character is a column boundary),
At least when writing data in which the first character string and the second character string are present in the database,
A portion that is a specific character string including the first character string and the second character string,
A program for causing an information processing device to execute a conversion process so as not to include the specific character string. The conversion process according to claim 1,
The program according to claim 1, wherein the program includes a character string in which the third character string exists in the target. The conversion processing according to claims 1 and 2,
The program according to claim 1 or 2, wherein the converted part and the other part are separated by a fourth character string. The conversion process according to claims 1 to 3,
The program according to any one of claims 1 to 3, wherein the target has a fourth character string. When the database includes data including a portion to which the conversion process according to claim 1 is applied,
A program for causing an information processing device to execute a process of changing data to a data before the process is performed on a portion subjected to the process. A program that causes an information processing apparatus to execute a process of converting a character string including a character string that satisfies the condition A into a character string that includes only a character string that does not satisfy the condition A,
In the conversion processing, what is converted into is determined depending on what the character that satisfies the condition A is.
Partitioning the part that has executed the conversion process and the other part with a character string that satisfies the condition B;
When the character string satisfying the condition B continues for a number of times satisfying a predetermined condition (C times), it is converted into a character string satisfying the condition D that continues for the number of times determined by the value of C.
A program characterized by. The reading section,
Change part,
An erasing section,
At least one of a stream storage unit and a text storage unit,
A change storage section,
A writing section,
The acquisition part,
A database processing unit comprising: A program comprising the database processing unit according to claim 7. The reading unit according to claims 7 to 8,
A first step of determining whether there is information indicating where the database exists,
If it is determined in the first step that the information indicating the location of the database does not exist, a second step of saving the determined data in the text storage unit,
When it is determined in the first step that the information indicating the location of the database exists, at least one of the data read based on the information and the data created based on the data is stored in the text storage unit. The third step of storing in
If it is determined in the first step that information indicating the location of the database exists, a fourth step of storing the information in the stream storage unit;
Characterized by having,
The reading unit according to claim 7. The third step according to claim 9 is
If the data to be stored is a character string, it is separated by the first specific character as a boundary,
Creating a first data collection,
Separated by a second specific character existing in each element of the first data set,
Creating a second data set,
Characterized by having,
The program according to claim 9. A program for causing an information processing apparatus to execute at least one of the processes according to claims 9 to 10. The stream storage unit according to claims 7 to 8,
Information indicating where the database resides,
Where to store deleted data,
9. The stream storage unit according to claim 7, wherein at least one of the above is stored. A program that causes an information processing apparatus to execute the process according to claim 12. The text storage unit according to claim 7,
A database storage section,
A line boundary storage section,
A column boundary storage section,
A key row position storage unit,
A title row storage section,
Record start line storage section,
Characterized by having at least one of
The text storage unit according to claim 7. The database storage unit according to claim 14,
The database storage unit according to claim 14, wherein the contents of the database are stored. The line boundary storage unit according to claim 14,
15. The line boundary storage unit according to claim 14, wherein at least what character is used as a line/record boundary when a flat file database is handled is stored. The column boundary storage unit according to claim 14,
15. The column boundary storage unit according to claim 14, wherein at least what character is used as a column boundary when handling a flat file database is stored. The key string position storage unit according to claim 14,
The key string position storage unit according to claim 14, wherein the position of the key string in the database storage unit is stored. The title row storage unit according to claim 14,
Define the meaning of each column in the database store, or
15. The title line storage unit according to claim 14, wherein the position of a line defining the meaning of each column of the database storage unit is stored. The record start line storage unit according to claim 14,
Storing the position of the record in the database storage unit,
The record start line storage unit according to claim 14, wherein A program for causing an information processing device to execute at least one of the processes according to claims 14 to 20. The writing unit according to claims 7 to 8,
At least one of the data read from the position specified by the data stored in the text storage unit or the data stored in the stream storage unit is the data to be changed,
The data to be changed is changed based on the contents stored in the change storage unit,
An operation of storing the changed data in the stream storage unit, or outputting the changed data.
The writing unit according to claim 7. A program for causing an information processing apparatus to execute the process according to claim 22. The change storage unit according to claim 7,
An update storage unit,
A delete memory section,
9. The change storage unit according to claim 7, comprising at least one of the following. The update storage unit according to claim 24,
The update storage unit according to claim 24, which is a data aggregate. The data set according to claim 25 is an associative array,
Key is the value used in the database key column,
26. The data aggregate according to claim 25, wherein the value is a data aggregate (hereinafter referred to as “second data aggregate”). The second data set according to claim 26 is
27. The second data set according to claim 26, which is an associative array. The associative array according to claim 27,
The key is the value used for the database column,
28. The associative array according to claim 27, wherein the value is a value written in a field of the database. A program for causing an information processing device to execute at least one of the processes according to claims 24 to 27. A data set that returns the second data by using the first data as a key,
The second data is a data aggregate that returns the second B data using the second A data as a key,
The first data is a database key column,
The second A data is a database column,
The second B data is the value written in the field of the database,
A program characterized by representing each. The update storage unit according to claim 24,
The update storage unit according to claim 24, which is as described in claim 29. The deletion storage unit according to claim 24,
The deletion storage unit according to claim 24, which stores a key string of a record to be deleted. A program for causing an information processing device to execute at least one of the processes according to claims 29 to 31. The changing unit according to claims 7 to 8,
Storing no data in the update storage unit in the update storage unit, the data aggregate having 0 elements;
If a target key string exists in the update storage unit, a step of acquiring a second data aggregate corresponding to the target key,
Writing a combination of a target column value and a field to the second aggregate;
Storing the written second aggregate in an update storage unit as a value corresponding to the target key string;
9. The changing unit according to claim 7, which further comprises: A program for causing an information processing device to execute the process according to claim 33. The erasing section according to claims 7 to 8,
A step of confirming that no data is stored in the deletion storage section,
If it is confirmed by the step that the data is not stored, the deletion storage unit is changed to a data aggregate having 0 stored keys, and
A step of confirming whether the data to be stored in the deletion storage section already exists in the deletion storage section,
If it is confirmed by the step that the data to be stored in the deletion storage unit does not exist in the deletion storage unit, a step of storing the data to be stored in the deletion storage unit in the deletion storage unit,
The change storage unit according to claim 7, further comprising: The deletion storage unit according to claim 35,
The deletion storage unit according to claim 35, which is a data aggregate. The deletion storage unit according to claim 35,
37. The deletion storage unit according to claim 35, which is a list or a collection. A program for causing an information processing device to execute at least one of the processes according to claims 35 to 37. The acquisition unit according to claim 7 to 8,
A first step of searching the change storage,
With the second step of searching the text store,
The acquisition unit according to claim 7, comprising at least one of them. The acquisition unit according to claim 39,
40. The acquisition unit according to claim 39, wherein the search of the text storage unit is not performed when the corresponding data exists in the change storage unit. The first step according to claim 39 is
If the corresponding data exists in the deletion storage unit, output a result indicating that the corresponding data does not exist, and
If the corresponding data does not exist in the deletion storage unit and the corresponding data exists in the update storage unit, output the corresponding data,
40. The first step of claim 39, characterized by: The second step according to claim 39,
At least output the result that the corresponding data does not exist if at least one of the applicable record or column does not exist,
If the corresponding record and column exist, output the data existing in the record and column,
40. The second step of claim 39, characterized by: The changing unit according to claims 7 to 8,
A first step of converting a numerical value (hereinafter referred to as "first numerical value") into a character string meaning the numerical value when storing the numerical value;
Performing the process according to claim 33 to 34 on the character string created by the step,
The modification unit according to any one of the seventh to eighth embodiments, characterized in that The first step according to claim 43,
A first step of calculating the numerical value from among several integers closer to 0 than the numerical value, the integer having the smallest difference from the numerical value;
A second step of calculating an absolute value of a difference between the numerical value and the numerical value calculated by the first step;
A third step of repeating the process of multiplying the numerical value calculated by the second step by 10 until it becomes an integer,
A character string obtained by concatenating a character string obtained by converting the numerical value created by the first step into a character string, a symbol meaning a decimal point, and a character string obtained by converting the numerical value created by the third step into a character string. The fourth step to create,
44. The first step of claim 43, comprising: A program for causing an information processing apparatus to execute at least one of the processes according to claims 43 to 44.