Abstract:
A method of processing a dynamic database in a distributed processing system based on CORBA platform includes calling a generic method in a server, detecting data by the called generic method, storing the detected data, and returning the detected data to a client, in the distributed processing system. The detected data is initially stored in a local memory. The generic method then creates a storage area for the data based on the number of data units that were detected, and based on the size of the detected data unit. In this manner, there is no need to pre-define the structure of the storage are before performing the query.

Description:
BACKGROUND OF THE INVENTION  
         [0001]    1. Field of the Invention  
           [0002]    The present invention relates to a method for processing a database in a distributed processing system and, more particularly, to a method for processing a dynamic data base in a distributed processing system, based on a Common Object Request Broker Architecture (CORBA) platform.  
           [0003]    2. Background of the Related Art  
           [0004]    An Object Request Broker (ORB) is a virtual system for communicating between objects in a distributed object environment, and CORBA is a standard specification of the ORB. ORB is arranged by an Object Management Group (OMG) to standardize the object oriented technique.  
           [0005]    Generally, a client that requests a service and an object implementation, providing the service, give and take a request or a service result (returned value) through the ORB, in the distributed object environment, and then the process is progressed. To begin with, the client passes a name and request content of the object, which is to be served, to the ORB. Then, the ORB finds the object implementation, based on the name, and transmits the requested contents. The object implementation returns a result of the service performance (return value) to the ORB, and the ORB transmits the result to the client. The client should be compatible with the interface of the ORB, to use a service of the optional object implementation. In addition, an Interface Definition Language (IDL) is used for defining the interface.  
           [0006]    A platform is characterized as the hardware or software that forms the basis of a computer system. That is, an Operation System (OS) or an application is operated in a hardware or software environment.  
           [0007]    [0007]FIG. 1 illustrates database processing in a background art distributed processing system, based on the CORBA platform. A process is shown in which a client  10  accesses a database  30 , of a server  20 , and obtains data through a distributed system, based on the CORBA platform. Although it is not shown in FIG. 1, the server  20  consists of a plurality of objects, and there is an object that processes the database in the plurality of objects. The object processing the database includes a plurality of methods.  
           [0008]    As shown in FIG. 1, when the client  10  calls the method on the server  20 , the corresponding method detects the data, wanted by the client  10 , in the database  30 . The server  20  then returns the data to the client  10  through an Internet Inter-ORB Protocol (IIOP)  40 . According to the method, various methods are required because there are various requests by the client  10  for the data.  
           [0009]    There are two parameters that are required when the client  10  calls the method. These are a Structure Query Language (SQL) string, for detecting data of the database  30 , and a pointer of a data structure, for allocating the detected data. A transmission and a return of the parameters are made by a “call by reference” method. The SQL string is a query for the data that is wanted, and the data structure defines a structure and a formation of a storing space for storing the detected data.  
           [0010]    The call by reference method is a method not for giving and taking a real value or data, but for giving and taking a pointer of a memory area, in which a real value or data is stored. And the above-mentioned pointer may be referred to as a reference pointer.  
           [0011]    [0011]FIG. 2 is an exemplary view showing an IDL for the call by reference method. Generally, the client  10  finds a reference pointer of the database process object in the CORBA platform server  20 . Then, the client  10  calls a method of the server  20  through the reference pointer. The called method detects the wanted data in the database  30  and then constructs the detected data into the data structure form, defined by the IDL, to transmit it to the client  10 . In addition, the data structure is defined in the respective method.  
           [0012]    If the method called by the client  10  does not exist or does not satisfy the client&#39;s request, the server  20  defines a new method. Thereafter, the server  20  should compile the IDL that is coded after adding the newly defined method to the previously defined methods.  
           [0013]    [0013]FIG. 3 is a flow chart showing a database processing method using the background art CORBA platform. As shown therein, the client  10  finds the reference pointer of the database processing object in the server  20  (S 1 ) and calls the method of the server  20  through the reference pointer (S 2 ).  
           [0014]    The called method detects the data required by the client  10 , in database  30 , through a search condition of the SQL string. Also, the called method allocates the storing spaces, according to the data structure form defined by the client  10  (S 3  and S 4 ), and copies the detected data to the allocated storing space (S 5 ). In addition, a result value calculated by the above processes (S 3 , S 4 , and S 5 ) is transmitted to the client  10 , through the ORB  40  (S 6 ).  
           [0015]    An embodiment for processing the database using the background art distributed processing system, based on the CORBA platform, will be described in more detail with reference to FIGS. 2 and 3. The client  10  finds a reference pointer of the database processing object, located in the server  20 , to detect the wanted data, by accessing the database  30 . After that, the client  10  calls the corresponding method using the SQL string and the data structure pointer as method calling parameters. The SQL string is a parameter related to the query of the client. The called method detects the corresponding data using the SQL string as a database searching condition. The server  20  allocates the storing space according to the data structure form defined by the called method and copies the detected data to the allocated storing space.  
           [0016]    The result value calculated through the above processes is stored in a certain memory area of the server  20  and returned to the memory area of the client  10 , pointed to by the data structure pointer, through ORB  40 . For example, assume that items of “name”, “customer number”, “birthday”, and “customer score” of customers having a customer score greater than 500 points are detected within the database by the client  10 , among various information related to the customers stored and managed in database  30 . Further assume that the detected data are “AAA”, “1011”, “05-27-1977”, “501”, “BBB”, “1120”, “11-20-1972”, “620”, “CCC”, “1313”, “10-28-1974”, and “550”.  
           [0017]    The method-A IDL call of client  10  is shown in Table 1, below.  
                                                                         TABLE 1                                       Step A                Struct structA           {           string strA; /“name” item/           short intA1; /“customer” item/           date datA2; /“birthday” item/           short intA3; /“customer score” item/           };                Step B                typedef sequence&lt;structA&gt; returndataA;                Step C                short methodA(in string SQLstring, out returndataA retVal);                      
 
           [0018]    Step A defines the data structure that will be detected in database  30 . Step B declares the data structure, defined in step A, as a sequence type. Step C is a sentence for calling a method having two parameters. As described above, if the data structure is declared as the sequence type, arrays having the same number of stored data are generated, so that memory is not wasted.  
           [0019]    The client  10  creates the data structure reference pointer and the SQL string parameters and calls the corresponding method in the server  20  (Step C). The called method detects the corresponding data in the database  30  and allocates the storing space, in the form defined by the data structure. In addition, the method copies the detected data to the allocated storing space.  
           [0020]    The result value, calculated through the above processes, is stored in a certain memory area of the server  20 . After that, the result is returned to the memory area of the client  10 , pointed to by the data structure pointer, through the ORB  40 . In addition, the client  10  accesses the memory area in which the returned value is stored and outputs the corresponding data.  
           [0021]    As described above, the server  20  should add a new method to the database processing objects, when no current method is able to accept the request of the client  10 . In addition, when the new method is added, both the original methods and the new method should be compiled to redefine the IDL. As new methods are added, the corresponding objects get larger.  
           [0022]    Also, in the process of designing the database program, the developer should consider all prospective client requests and should define a plurality of methods and data structures to support these client requests. Therefore, it takes a lot of time and expense to develop the program.  
           [0023]    The above references are incorporated by reference herein where appropriate for appropriate teachings of additional or alternative details, features and/or technical background.  
         SUMMARY OF THE INVENTION  
         [0024]    An object of the invention is to solve at least the above problems and/or disadvantages and to provide at least the advantages described hereinafter.  
           [0025]    Therefore, an object of the present invention is to provide a method for processing a dynamic database in a distributed processing system, based on CORBA platform, that defines data structures, processed between a client and a server, and allocates memory for the structures automatically.  
           [0026]    Another object of the present invention is to provide a method for processing a dynamic database in a distributed processing system, based on CORBA platform, by which requests of the client can be accepted using a method.  
           [0027]    To achieve these and other advantages and in accordance with the purpose of the present invention, as embodied and broadly described herein, there is provided a method for processing a dynamic database in a distributed processing system, based on a CORBA platform, including calling a generic method of a server; detecting data using the called generic method; storing the detected data in a local memory; generating or expanding a storing space, according to the form and number of the detected data; copying the detected data in the local memory, in a storing space generated in a certain memory area of the server; and returning the detected data to a client.  
           [0028]    Additional advantages, objects, and features of the invention will be set forth in part in the description which follows and in part will become apparent to those having ordinary skill in the art upon examination of the following or may be learned from practice of the invention. The objects and advantages of the invention may be realized and attained as particularly pointed out in the appended claims. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0029]    The invention will be described in detail with reference to the following drawings in which like reference numerals refer to like elements wherein:  
         [0030]    [0030]FIG. 1 illustrates database processing in the background art distributed processing system, based on a CORBA platform;  
         [0031]    [0031]FIG. 2 illustrates an Interface Definition Language (IDL) for several methods;  
         [0032]    [0032]FIG. 3 illustrates a flow chart showing the background art method for database processing in the distributed processing system, based on the CORBA platform;  
         [0033]    [0033]FIG. 4 illustrates a method for processing a dynamic database according to the present invention;  
         [0034]    [0034]FIG. 5 illustrates an IDL for a preferred method of processing a dynamic database, according to the present invention; and  
         [0035]    [0035]FIG. 6 illustrates a flow chart showing the method for processing the dynamic database in the distributed processing system, based on the CORBA platform, according to the present invention. 
     
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS  
       [0036]    [0036]FIG. 4 is a block diagram showing a method for processing a dynamic database in a distributed processing system, based on a Common Object Request Broker Architecture (COBRA) platform, according to the present invention. A form of data detected in the database is declared as an Any type, and a structure of the data is declared as a sequence type. Various requests of clients can be accepted using a method. The Any type may take any one of numerous data forms, such as string, integer, float, decimal, and date, and is able to present all of the data forms used in the database  30 . In addition, a memory space declared as the sequence type has basically the same structure as that of an array structure. However, it is different in that the memory space is generated automatically to have the same number of bits (i.e., size) as that of the data. If the storing space, which has been declared once, is declared as the sequence type again, the storing space is expanded as two-dimensional space and then expanded to n-dimensional space, if the space is declared as the sequence type n times.  
         [0037]    The method for processing a dynamic database in a distributed processing system, based on a CORBA platform, according to the present invention comprises calling a generic method of a server  20 ; detecting data by the called generic method; storing the detected data in a local memory; generating or expanding a storing space according to the form and number of the detected data; copying the detected data in a local dynamic memory and in a storing space generated in a certain memory area of the server  20 ; and returning the detected data to a client  10 .  
         [0038]    [0038]FIG. 6 is a flow chart showing the method for processing the dynamic database in the distributed processing system, based on the CORBA platform, according to the present invention. The operation of the present invention will be described, as follows, with reference to FIG. 6. The client  10  finds a reference pointer of a database processing object (S 11 ) and calls the generic method in the server  20 , using the SQL string and a pointer of the generic data structure as parameters (S 12 ). In defining the data structure, the client  10  does not define the data type or structure, but defines a generic data structure using declarative functions of Any type and of sequence type, so that the memory area is automatically generated according to the structure or the number of the detected data.  
         [0039]    The called generic method detects the corresponding data in the database  30 , under the searching condition of the SQL string (S 13 ). The detected data are stored in the local dynamic memory (S 14 ). In addition, the generic method generates a storing space by instantiating the data structure. After that, the data stored in the local memory are copied to the generated storing space (S 16  and S 17 ).  
         [0040]    The processes S 13 ˜S 17  are repeatedly performed until all the data satisfying the SQL string (Query) are detected (S 18 ). When the processes S 13 ˜S 17  are completed, a result value in the storing space is returned to the client  10 , in the same manner as in the background art (S 19 ).  
         [0041]    In process S 15 , the detected data are stored in the local memory in a linked-list form, regardless of the data table structure. To return the detected data to the client  10 , the generic method allocates the storing spaces as the number of the data using the sequence type declarative function and declares the respective storing spaces as Any types. This is referred to as an instantiation process.  
         [0042]    Processing procedures for process S 11  and process S 19  are the same as the processing method in the background art distributed processing system, based on the CORBA platform.  
         [0043]    [0043]FIG. 5 is a preferred embodiment of an Interface Definition Language (IDL) method according to the present invention. The method for processing a dynamic database in the distributed system, based on the CORBA platform, of the present invention will be described with reference to FIG. 5.  
         [0044]    Assume the client  10  wants to detect items of “name”, “customer number”, “birthday”, and “customer score” of the customers having customer scores greater than 500 points, among the various information related to the customers stored and managed in database  30 . Further assume that the detected data are “AAA”, “1101”, “05-27-1977”, “501”, “BBB”, “1120”, “11-20 1972 ”, “620”, “CCC”, “1313”, “10-28-1974”, and “550”.  
         [0045]    A generic method calling IDL of the client  10  is provided in Table 2, below.  
                                                                         TABLE 2                           Step AA                Struct elementValue           {           short type; /1:integer 2:float 3:string 4:decimal 5:date/           any value; /any type for real value/           };            Step BB                typedef sequence&lt;elementValue&gt; ElemSeq;            Step CC                typedef sequence&lt;ElemSeq&gt; ReturnSeq;            Step DD                short genericMethod(in string SQLstring, out ReturnSeq RetVal);                      
 
         [0046]    Step AA defines the generic data structure so that the detected data has the Any type data form. Step BB declares the data structure defined in step AA as the sequence type and generates an array of first structure. In addition, step CC declares the data structure defined in step BB as the sequence type again, and generates the array of a two dimensional structure. Step DD shows the calling for the generic method.  
         [0047]    To begin with, the client  10  calls the generic method by setting the “pointer of the generic data structure” and the “SQL string” as parameters, which are respectively defined as Any type and sequence type. The called generic method applies the SQL string through a dynamic SQL mode, supported by database  30 . Then, the corresponding data is detected and stored in the local memory in a linked-list form.  
         [0048]    The first row data is all detected and the generic method instantiates the data structure in a certain memory area of the server  20 , whereby a storing space for copying the row data is generated (Step BB). The storing space generated by the instantiation is comprised of four arrays declared as Any types, and the four elements of detected data (“AAA”, “1011”, “05-27-1977”, and “501”) comprising the first row will be stored in the four respective arrays, as shown by Table 3.  
                                                         TABLE 3                                   Array 1   Array 2   Array 3   Array 4                                    Type   Any type   Any type   Any type   Any type       Declaration       Stored Value   AAA   1011   05-27-1977   501                  
 
         [0049]    When the generic method detects all of the data satisfying the SQL string (Query), that is, when the second row data (“BBB”, “1120”, “11-20 1972 ”, “620”) and the third row data (“CCC”, “1313”, “10-28-1974”, and “550”) are detected, the one-dimensional array is declared once again as the sequence type (Step CC) and the two-dimensional storing space is generated as shown by Table 4.  
                                                         TABLE 4                                   Array 1   Array 2   Array 3   Array 4                                    First Row Data   Any Type   Any Type   Any Type   Any Type       First Row Data   Any Type   Any Type   Any Type   Any Type       First Row Data   Any Type   Any Type   Any Type   Any Type                  
 
         [0050]    Of course, the detected respective data are stored in the local memory and then copied to the memory area as a row-data unit. In addition, whenever the row data are copied to the memory area, four storing-areas (arrays), which are declared as Any type, are expanded to store the data.  
         [0051]    The storing areas (3*14 arrays) generated in the memory area store the data, as shown by Table 5.  
                                       TABLE 5                                       First Row Data   AAA   1011   05-27-1977   501           Second Row   BBB   1120   11-20-1972   620           Data           Third Row Data   CCC   1313   10-28-1974   550                      
 
         [0052]    As described above, the data structure defined by the generic method is generated and expanded dynamically by the Any type and the sequence type. That is, the data structure of the generic method is not defined to have a fixed form, before calling the method, but is flexibly generated according to the form and the number of the detected data, after searching the database  30 .  
         [0053]    When all of the corresponding data are detected, the detected result value is stored in the memory area of the client  10 , pointed to by the pointer of the data structure, through the ORB. The client  10  accesses the memory area, in which the result value is stored, and outputs the corresponding data.  
         [0054]    As described above, according to the present invention, the method IDL is defined generically, and the defined method automatically generates and expands the memory area in which the detected data is stored. Thereby, a range of program designing is minimized. Therefore, the developer of the program is able to reduce the time and expense spent defining the IDL of the plurality of methods and defining the data structure.  
         [0055]    Also, for a transaction request of the client that is not defined, the background art defines new IDLs and must then compile them. However, according to the present invention, various transaction requests of the client can be accepted using the generic method and the generic data structure, which are defined when the database program is developed.  
         [0056]    Also, according to the present invention, the problem of dynamic binding of the data (i.e., a form or a structure of the data cannot be known until the data is detected) generated while processing the SELECT query, of the background art database, can be solved. Thereby, processing for various distributed transactions, based on the CORBA platform, and the function of the processor can be increased, accordingly.  
         [0057]    The foregoing embodiments and advantages are merely exemplary and are not to be construed as limiting the present invention. The present teaching can be readily applied to other types of apparatuses. The description of the present invention is intended to be illustrative, and not to limit the scope of the claims. Many alternatives, modifications, and variations will be apparent to those skilled in the art. In the claims, means-plus-function clauses are intended to cover the structures described herein as performing the recited function and not only structural equivalents but also equivalent structures.