TWI557582B - Software tools and methods for efficient access to information - Google Patents

Description

Software tool and method for efficiently accessing data

The present invention relates to an architecture for object and array storage, and more particularly to an access path for application data access.

Conventional data management, such as using object stream technology to store data; and object stream is an efficient file construction method, as follows: 1, because Java's object-oriented circles have persistence characteristics, objects are stored in the file layout (layout Of a file) will be exactly the same as the memory layout. 2. All related objects are managed in an array. 3. As long as we can provide the path to the data, no matter where the data exists in the file, the data can be quickly retrieved.

Accordingly, the present invention provides a method for efficiently accessing data by:

(a) store a relevant information through an object.

(b) The objects are stored in a corresponding array via a steering engine.

(c) storing the array storing the object in a corresponding one of the categories.

(d) Obtaining an access path for the related storage of the object by the above steps.

(e) searching for and acquiring the object via the access path.

(f) the objects are stored in the array, and the array is stored in another object, and the objects and arrays are stored in a layer stack storage manner or a plurality of the objects are stored through the array. When the array stores an upper limit of the storage space of the object, the storage space is doubled by an expansion mechanism for storing the object.

Further, the above-mentioned steering engine is a data-oriented engine and an array-oriented engine.

Further, the above data steering engine includes access.

Further, the above array steering engine includes: insert, modify, delete, and access.

The invention further provides a file for the efficient access to the software tool ISG (Information System Generator Information System ISG) to facilitate access to the data in the file, the software tool is a software tool using the above method, The file creation software tool is referred to in the present invention as An Efficient Building File System Generator abbreviated as BFS-G. The BFS-G system comprises: a category of at least one object and an array storing the objects, the object being stored in the array. a storage space, and an expansion mechanism is provided in the array. When the storage space reaches an upper limit value, the storage space is doubled by the expansion mechanism for storing the object and transmitting the object. Storing in the array to form an access path, the object stores a related information; the object includes at least one steering engine; the guiding engine provides a response according to an access path for storing the related information, and the response includes The above objects.

Further, the mechanism of the above software tool includes: calling array_name_add(object_name elemet): void, calling array_name_expandCapacity():void, calling remove_array_name():void, calling remove_array_name(int idx):void, calling get_array_name_size():int, calling Get_array_name(int idx): object_name, call array_name_isEmpty(): boolean, call get_variable_name(): data-type, and call set_variable_name(data-type element):void.

Further, BFS-G is one of the functions of ISG software development tools called file creation. ISG includes six functions: file creation, window connection, data processing screen, data display, preview and printing. The above IFS BFS-G system Enter a category name and its attributes to generate a Java program.

Further, the translation of the above response path is as follows: Suppose the path is the category name/array 1/array 2/data name. The algorithm for translating the path to the data temporary storage array of the attribute data name is called Retriving_data_name. The flow of the algorithm Retriving_data_name is as follows: First, enter a category Name, an array 1, an array 2, a data name and an array size; output an array matrix; the array matrix comprises an array matrix string, the array matrix string storing the new data of the array name of the data name a type; the initial value of the preset address is zero; the category name of the first object is converted from an object into the category name; the category of the index 1 of an object 1 is declared and the object 1 is The first variable has a starting value of zero, and the first variable is smaller than the size of the array 1; the index 1 extracts the array 1 from the first variable in the object 1; and declares an indicator 2 of an object 2 The category and the second variable of the second variable of the object 2 have a starting value of zero, and the second variable is smaller than the size of the array 2 of the index 1; the index 2 extracts the array 2 from the second variable in the object 2 The above information name 2 the indicator of the presence of the array.

The code of the above algorithm Retriving_data_name is as follows:

To execute Retriving_data_name, the user must enter the path class_name, array1, array2, data_name, and array_size. The array_size is the size of the array arrays, and the output is array arrays. Then how to translate the four paths into the above algorithm is described as follows:

(a) The first path class_name, the fourth line of ois.readObject() indicates that one of the class class_name objects is read from the file, and the object temporarily exists in the_first_object. The data_type_of_data_name user of line 1 can refer to the architecture diagram of the file system designed by the user, such as the second A picture, the second B picture, the second C picture and the second D picture, so that the data type of the data_name can be easily and quickly found, or It is known from the BFS-G software tool. If the user has set up the file using BFS-G, the user can find the value of class name is class_of_object2, the field name is data_name and the field Data type is entered in the fields of the fifth to eighth fields. That is, the value required by data_type_of_data_name (this category name class_of_object2 needs to be checked first, please refer to the following step A and then refer to data_type_of_data_name).

(b) The second path array1, the object the_first_object stores an array array1, tmp1 is an object reference taken by the array array1, because it is an array, use the for loop to sequentially take out the object in the array1 temporarily exists tmp1 (see Line 5 to line 7), the following explains how to retrieve each object sequentially from the array array1.

Users of Class_of_object1 of Class A and Line 6 can refer to the architecture diagram of the file system they designed. This architecture diagram can identify the category name of the object stored in the array array1, or learn from the BFS-G software tool. Because BFS-G provides interfaces such as the fourth to eighth Let the user set the category and the attributes of each category, and then archive. In the fifth to eighth pictures of the interface, the user in the picture can find the Class name as class_name, the field name is array1 and the field Data type. Is the Array, the field Array datatype input is the class name required by class_of_object1.

B, BFS-G provides 7 array steering engine, the object the_first_object can call this 7 array steering engine, because array array1 is in the object the_first_object, this object has this 7 array steering engine, line 5 of the_first_object.get_array1_size() indicates array array1 The number of objects, lines 5 to 7 can be sequentially retrieved from the array array1 to temporarily store the object tmp1. Line 7 of tmp1=the_first_object.get_array1_class_of_object1(i1) will take the object from the array array1 temporarily to tmp1, and start the first object from the index i1=0 and continue.

(c) The third path array2, the object tmp1 stores an array array2, and the tmp2 temporary storage array array2 takes the object reference. For the description of lines 8 to 10, please refer to (b) above.

The fourth path data_name puts the data of a data attribute data_name in the array arrays, the attribute data_name in the object tmp2, and the line 11 calls the data steering engine getdata_name() by the object tmp2, and takes out the data value of the data_name. Into the array arrays, the array arrays are stored from the index pointer=0 and then placed sequentially (see line 2).

Further adding a Join Approach mechanism, the Join Approach mechanism is to join multiple files in one file by using a login screen of the pull-down menu.

Further, the above BFS-G adds an extension mechanism.

The effect of the invention is:

1. The category unit of the present invention is a multi-layer architecture. By means of an array and a steering engine mechanism, a path is used to translate the code, and the translated code can speed up the data access time.

2. The expansion mechanism of the present invention is for preventing the data storage space from being stored in the array after storing too many objects, so the invention has the effect of elastically expanding the data storage space.

3. The Join Approach mechanism of the present invention, the Join Approach mechanism is to join multiple files in one file by using a login screen of the pull-down menu.

[First figure] is a standard mode category diagram of the system file architecture of the present invention.

[Picture A] is a file structure diagram of a company of the present invention, taking a contract/shipper file as an example.

[Second B] is a file structure diagram of a company of the present invention, taking each shipment overhead file as an example.

[Second C] is a file structure diagram of a company of the present invention, taking the type of shipping overhead type file as an example.

[Second D] is a file structure diagram of a company of the present invention, taking the Taiwan address file as an example.

[Third Figure] is a flow chart of the present invention.

[Fourth figure] is the BFS-G file creation tool of the present invention, and uses this tool to set the category name of all files, which is the name of a company operation information system 17 file category.

[fifth figure] is an example of the contract/shipper file category invoice_array. The BFS-G of the present invention sets its data member for the category invoice_array, and presses the Translate to an object java code button to generate the invoice_array.java code. This code is the same as shown in the invoice_array category diagram in the second diagram.

[Sixth figure] is a category of proforma_invoice_data which is a contract/shipper file file. The BFS-G of the present invention sets its data member for the category proforma_invoice_data, and presses Translate. To a java code button, the proforma_invoice_data.java code is generated, which is the same as the second map of the proforma_invoice_data category.

[Seventh figure] is a category of contract/shipper file category pi_data. The BFS-G of the present invention sets its data member for the category pi_data, and presses the Translate to a java code button to generate the pi_data.java code. The code is the same as shown in the pi_data category diagram in the second diagram.

[Eight image] is an example of the batch goods_payout_data of each batch of shipping cost files. The BFS-G of the present invention sets its data members for the category goods_payout_data, and presses the Translate to an array code button to generate goods_payout_array.java and goods_payout_data.java. The code, the two sets of code are the same as the goods_payout_array category diagram and the goods_payout_data category diagram in the second diagram.

[The ninth] is an example of how to log in each shipment of shipments, and how to join each shipment of overhead files and shipping overhead type files.

Combining the above technical features, the main construction and technical features of the software tool and method thereof for efficiently accessing data of the present invention can be clearly shown in the following embodiments.

Structures and Embodiments of the Invention Referring to the first to ninth embodiments, the method of the present invention includes: (a) storing an information through an object; (b) storing the object via a guide engine add() And corresponding to the array; (c) the array for storing the object, wherein the array is in an object of a category, the object can be read from the file; (d) obtaining the relevant storage of the object by the above steps An access path, the path is an object read from the file, the first path is the category name of the object, and the second path is an array of the object, and the information of all the objects of the array can be accessed; (e) The object is searched for and obtained through the above access path.

In particular, the objects are stored in an array, and the objects are in an array, so that the objects are stored in the array layer to store the objects and the array, for example, at least one of the objects. Stored in the array, the array is stored in another object, and the other objects are stored in another array, and the objects and the array are stored in the above manner; and the guiding engine is a data-oriented engine And the array-oriented engine, wherein the data-oriented engine includes an access function, and the array-oriented engine includes: inserting, modifying, deleting, and accessing functions; and the path of the multi-level category map data is class_name/array1/array2 /.../arrayn/data_name.

Further, the file creation function of the BFS-G includes: establishing at least one object in a category and an array storing the objects to form an access path, the object storing a related information; the object includes a steering engine.

The foregoing steering engine provides a response according to an access path for storing the related information, and the response includes the above object.

Further, the software tool is BFS-G, and the BFS-G system inputs a category name and its attributes, thereby generating a Java program.

Further, the BFS-G translation steering engine includes: call array_name_add(object_name elemet): void, call array_name_expandCapacity():void, call remove_array_name():void, call remove_array_name(int idx):void, call get_array_name_size():int Call get_array_name(int idx): object_name, call array_name_isEmpty(): boolean, call get_variable_name(): data type, and call set_variable_name(data type element):void.

Further, the expansion mechanism of BFS-G is to call the above array_name_expandCapacity():void.

Combining the above technical features, please refer to the standard mode category diagram of the file structure of the first figure. The class_name, array_name, variable_name, class_name_of_object and data_type in the figure indicate that the parameter names when using the BFS-G translation program have their meanings and their meanings are English means the same, class_name represents the name of a category, array_name represents an array name, and variable_name represents An attribute name, class_name_of_object indicates the name of the object category stored in the array, data_type indicates the data type of a variable, and element indicates any variable name.

The file represented in the first figure may have only one category map or multiple-level category map. Although the attributes and arrays declared in the category map represent *, there must be at least one announcement in the part of the declared attribute.

The above-mentioned steering engine provides a data-oriented engine and an array-oriented engine. The data-oriented engine is used to process the general variable variable_name, and its data type is data_type, such as taking the variable variable_name data value: (1) calling getvariable_name(): data_type; Returns the data content of this property variable_name.

For example, set the variable_name data value: (2) call setvariable_name(data_type element):void; set the data value element of variable_name to this data attribute variable_name.

The following are BFS-G translations of getvariable_name():data_type; and setvariable_name(data_type elemet):void; syntax of the code;

Special note: * in the first figure means zero to more.

The present invention further illustrates the following seven mechanisms with the array steering engine.

The array-oriented engine operation requires the assistance of the following attributes: array_name_count indicates the number of objects in the array, the name of the array is array_name, and the category name of the array storage object is class_name_of_object.

The first one is call array_name_add(class_name_of_object element):void;, the call indicates that the object will be stored in the array in order, and the name of the array is array_name, and the object referenced will be element, the first object The reference will be placed at index 0 of the array, then the second object reference will be placed at index 1, and so on. If the array is full, the array_name_expandCapacity() will be called to expand the storage capacity to the original array. Doubled; the syntax of the BFS-G translation array_name_add(class_name_of_object element) code is as follows:

The second is to call array_name_expandCapacity():void; to expand the capacity of the array array_name to twice; the syntax of the BFS-G translation array_name_expandCapacity() code is as follows:

The third is to call remove_array_name():void; delete all objects in the array array_name; BFS-G translates the remove_array_name() code as follows:

The fourth is to call remove_array_name(int idx):void; it will delete the object of the array array_name; BFS-G translates remove_array_name(int idx):void; the syntax of the code is as follows: public void remove_array_name(int idx){

The fifth is called get_array_name_size(): int; the number of objects in the array array_name is returned; BFS-G translates get_array_name_size(): int; the syntax of the code is as follows:

The sixth is call get_array_name_class_name of_object(int idx):class_name_of_object; extract one object from the array; BFS-G translates get_array_name_class_name of_object(int idx):class_name_of_object; the syntax of the code is as follows:

The seventh is call array_name_isEmpty():boolean; it will return true or false. If the array is empty, no object will be stored, it will return true, otherwise it will return false. BFS-G translates array_name_isEmpty(): boolean; the syntax of the code is as follows:

For the continuation, please refer to the second A diagram, the second B diagram, the second C diagram and the second diagram D. The file system architecture of the present invention and the four files in the file system of a company operation information system are taken as an example. The four files are: contract/shipper file, each shipment cost file, shipping expense type, and Taiwan address file.

The contract/shipper file of the present invention stores commercial contracts and shipping notices, which include a three-tier category; a category invoice_array, a category profroma_invoice_data, and a category pi_data.

The object in the category invoice_array includes the array pi_proforma_invoice and the array si_shipping_invoice.

The array pi_proforma_invoice stores the commercial contract and the array si_shipping_invoice stores the shipping notice.

Since both the commercial contract and the shipping notice store the same type of information, the present invention stores the same type of data in the category proforma_invoice_data, including the company name, customer name, Pi number, quotation condition, scheduled shipping date, etc.; because the product number, product description, quantity, unit, unit price, etc. of the object of the category proforma_invoice_data have multiple pieces of the same type of information as the object of the category proforma_invoice_data The traits are the same, so the object will be stored in the category pi_data, and the object will be stored in the pi_array array of the object of the category profroma_invoice_data associated with it.

The attribute declaration syntax of the file category map of the present invention is variable_name: data_type; the pi number, the company name, the customer name, the quotation condition, and the scheduled shipping date are declared according to the above syntax, as follows pi_number: int;, pi_company: String, pi_customer: String, pi_term:String, and pi_date:date, because the pi number, company name, customer name, quotation condition, and variable_name of the scheduled shipping date have been designed as pi_number, pi_company, pi_customer, pi_term, and pi_date, and their data_type has been designed as an integer. , data type of string, string, string and date (see Figure 2A).

The method and the steps of the file type map of the present invention are shown in the third figure. The object is stored through the object, such as attributes, etc., and the object is stored in the attribute or the array-oriented engine to store the object through the data-oriented engine. The image is stored in the associated array, and then stored in the relevant category through the array storing the object, and an access path is generated, and the object or the address stored by the array can be known by the access path.

The fourth to eighth embodiments of the present invention provide the interface provided by the BFS-G. After inputting the parameters through the interface, the parameters of the parameter translation attribute and the Java program for guiding the engine code can be transmitted through the BFS-G.

As shown in the fourth figure, BFS-G provides all the category names in the configuration file, such as: Class Name fields, such as goods_payout_data, goods_payout_kind_data, invoice_array, profroma_invoice_data, pi_data, and taiwan_address_data; and categories goods_payout_data, category goods_payout_kind_data, and category taiwan_address_data All the objects produced Since an array is required for management, the BFS-G file creation will automatically generate an array of programs goods_payout_array.java, goods_payout_kind_array.java, and taiwan_address_array.java. For example, if you use the eighth interface of BFS-G, log in the properties of the categories goods_payout_data and press Translate to an array code button, which generates two Java code; goods_payout_array.java and goods_payout_data.java.

The field of the Date type of the Array in the fourth figure indicates the category name of the object stored in the array. For example, the field of the Class Name of the upper page of the fourth figure: the object of the category invoice_array has two arrays storing the category profroma_invoice_data. The object reference, so in the lower layout field Date type of the Array login category profroma_invoice_data; and the fourth picture below the showing additional attributes of record 3 in the buttom panel indicates that the mouse has just selected the third name of the class Name field The pen's invoice_array also indicates that the field of the Date type of the Array displays the category name profroma_invoice_data of the object stored in the array of objects of the category invoice_array.

As shown in the fifth figure, the category of the above fourth figure is set. The class name of the upper page selects the category invoice_array. The following settings are set according to the design of the category map category invoice_array of the second picture A, and the field name is set to pi_proforma_invoice. And si_shipping_invoice, because both are arrays, the Data Type is set to Array, and the # of dimension represents the dimension of the array, because the second A picture is designed as pi_profroma_invoice:proforma_invoice_data[];[] represents the array pi_profroma_invoice one-dimensional array, For example, [][] indicates two-dimensional, so the setting is 1 dimension, the size is set to 100, and the Array data type indicates the category name of the object stored in the array. Both store the object of the category profroma_invoice_data, and the Array data type field is set to Profroma_invoice_data, press the Translate an object java code button to generate the Java code; invoice_array.java.

As shown in the sixth figure, a category of profroma_invoice_data is set in the fourth figure above. Field name sets all attributes of the category. This category has an array of pi_array and general attributes pi_number, pi_company, pi_customer, pi_date, pi_expect_date, pi_term, pi_payout, pi_bank. , pi_total and si_total, the array pi_array settings refer to [0064], other general properties settings, just set the Field name and Data type, these materials can be learned from the second A map category proforma_invoice_data, press the Translate to a java code button , that is, generate Java code; proforma_invoice_data.java.

As shown in the seventh figure, a category pi_data of the fourth figure is set, and the Field name is set to pi_gu_number, pi_gu_statement, pi_amount, pi_unit, pi_price, pi_presently, etc., and the Data type can be from the category of the second A picture. Pi_data knows that pressing the Translate to a java code button will generate the Java code; pi_data.java.

As shown in the eighth figure, a category of goods_payout_data is set in the fourth figure, and the Field name is set to gp_si_number, gp_gpk_kinds, gp_sum, etc., and the Data type can be known from the category goods_payout_data of the second B picture, Translate to an array code button, which generates two Java code; goods_payout_array.java and goods_payout_data.java.

The ninth figure shows the Join Approach mechanism of the present invention. The Join Approach mechanism is a pull-down menu of the login screen. If the source of the pull-out menu is obtained from a file and the index of the menu is also stored, multiple files can be joined. In a file, the ninth figure describes how to join each batch of shipping cost file and shipping overhead type file, because the field type of the column is a pull menu, and the menu data is provided by the attribute cost category of the shipping cost category file. The information of this login is stored in the goods of the batches_payout_data category of each batch of shipping cost files. The object has an attribute gp_gpk_kinds_index which is an index for storing the drop-down menu. The company information system can use this gp_gpk_kinds_index to index the array of shipping overhead type files. G_oods_payout_kind_array takes all the information of the object of category goods_payout_kind_data.

In view of the foregoing description of the embodiments, the operation and the use of the present invention and the effects of the present invention are fully understood, but the above described embodiments are merely preferred embodiments of the present invention, and the invention may not be limited thereto. </ RTI> <RTIgt; </ RTI> <RTIgt; </ RTI> <RTIgt; </ RTI> <RTIgt; </ RTI> <RTIgt; </ RTI> <RTIgt;

Claims (9)

A method for efficiently accessing data by: (a) storing an associated information through an object; (b) storing the object in a corresponding array via a steering engine; (c) Storing the array of the object in a corresponding one of the categories; (d) obtaining an access path of the related storage of the object by the above steps; (e) searching for and acquiring the object via the access path; (f) The object is stored in the array, and the array is stored in another object, and the object and the array are stored in a layer stack storage manner or a plurality of the objects are stored through the array. The array stores the object. When the storage space of one of the objects reaches an upper limit, the storage space is doubled by an expansion mechanism for storing the objects. The method for efficiently accessing data as described in claim 1 is the data-oriented engine and the array-oriented engine. The above-described data-oriented engine includes access as described in the second paragraph of the patent application for efficient access to data. The method for efficiently accessing data as described in claim 2, the array steering engine includes: inserting, modifying, deleting, and accessing. A software tool for efficiently accessing data, which uses the software tool of claim 1 which comprises: establishing at least one object in a category and an array storing the object, wherein the object is stored in the a storage space in the array, and an expansion mechanism is provided in the array. When the storage space reaches an upper limit, the storage space is doubled by the expansion mechanism for storing the object and transmitting The object is stored in the array to form an access path, and the object stores a related information; the object includes at least one guiding engine; The foregoing steering engine provides a response according to an access path for storing the related information, and the response includes the above object. For the software tool for efficiently accessing data as described in claim 5, the mechanism of the software tool includes: calling array_name_add(object_name elemet): void, calling array_name_expandCapacity():void, calling remove_array_name(): Void, call remove_array_name(int idx): void, call get_array_name_size(): int, call get_array_name(int idx): object_name, call array_name_isEmpty(): boolean, call get_variable_name(): data-type, and call set_variable_name(data-type element ):void. The software tool for efficiently accessing data, as described in claim 5, is a file creation function of an ISG software development tool, and the present invention is called a BFS-G (Building file system generator). The BFS-G software development tool inputs a category name and its attributes to generate a Java program. For the software tool for efficient access to data as described in item 5 of the patent application, the translation of the above response path is as follows: Assume that the path is a category name/array 1/array 2/data name, and the path is translated as 撷The algorithm for taking the data temporary name array of the attribute data name is called Retriving_data_name, and the flow of the algorithm Retriving_data_name is as follows: First, input a category name, an array 1, an array 2, a data name, and an array size; An array matrix; the array matrix comprises an array matrix string, wherein the array matrix string stores a new data type of the array size of the data name; the initial value of the preset address is zero; The category name is converted from an object into a category name; Declaring a category 1 of an object 1 and a first value of the first variable of the object 1 having a starting value of zero, and the first variable is smaller than the size of the array 1; the indicator 1 is from the object 1 a variable is taken out of the array 1; a category of the indicator 2 of one object 2 and a second variable of the second variable of the object 2 are declared to be zero, and the second variable is smaller than the size of the array 2 of the index 1; The array 2 is taken from the second variable in the object 2; the data name is an array in which the index 2 exists. For example, in the software tool for efficiently accessing data as described in claim 5, a Join Approach mechanism is further added. The Join Approach mechanism uses a login screen of a pull-down menu to place multiple files in the Join window. In a file.