Abstract:
The invention relates to an apparatus and method of genericallly and transparently expanding and contracting a query comprising the steps of: receiving a first query comprising one or more search values, obtaining a second query by a first processing of the first query, executing the second query in a database, receiving a first result comprising one or more rows with instances of data from the database on the basis of the second query, and providing a second result by a second processing of the first result, wherein the first processing is done by expanding the first query according to one or more query functions, the second processing is done by contracting the first result, and in that the method further comprises the step of calculating an overall score for one or more query functions according to a second function.  
     The invention also relates to a computer-readable medium and a computer program element comprising computer program code means adapted to perform the method

Description:
[0001]    The present invention relates to a method of generically and transparently expanding and contracting a query, comprising the steps of:  
           [0002]    A. receiving a first query comprising one or more search values,  
           [0003]    B. obtaining a second query by a first processing of the first query,  
           [0004]    C. executing the second query in a database,  
           [0005]    D. receiving a first result comprising one or more rows with instances of data from the database on the basis of the second query, and  
           [0006]    E. providing a second result by a second processing of the first result.  
           [0007]    The present invention also relates to an apparatus for generically and transparently expanding and contracting a query, comprising:  
           [0008]    receiving means adapted to receive a first query comprising one or more search values,  
           [0009]    processing means adapted to provide a second query by a first processing of the first query,  
           [0010]    executing means adapted to execute the second query in a database,  
           [0011]    receiving means adapted to receive a first result comprising one or more rows with instances of data from the database on the basis of the second query, and  
           [0012]    processing means adapted to provide a second result by a second processing of the first result.  
         TECHNICAL FIELD  
         [0013]    This invention relates to a generic method and apparatus for expanding and contracting a query in order to include functionality in the form of query functions like Fuzzy logic and a rating/scoring function in a standardised query language, e.g. SQL, thereby providing access to multiple heterogeneous data sources and/or homogeneous sources.  
         BACKGROUND AND PROBLEM  
         [0014]    Searching of information in structured information sources like databases is most often done by using SQL (Standard Query Language) which is a very common standard query language to which almost every database has an interface.  
           [0015]    However, one of the disadvantages of SQL is that the results obtained by a query are presented to the user in the order that they are retrieved from the database. This gives the user a very poor general view of which result is the most important for him.  
           [0016]    Another disadvantage of SQL is that prior to the generation of an SQL query the type of the contents of the individual fields, i.e. field types/values, must be known. This is generally far from being the case. A type of field that varies very much from database to database is e.g. a field containing a date. Additionally the range of values, i.e. dimension, must be known in order to specify/construct a usable query. E.g., one needs to know if the values of a given row in a database are within a range of −1000 to 1000 or −1 to 1.  
           [0017]    Yet another problem is the handling of consistency of values for the individual fields. A great inconsistency may occur dependent on who enters the data and how the data is entered into a database. Different sales persons might input data for a given product differently. In a field which was designed to receive “Yes” and “No”, different people could enter: “Y”, “y”, “N”, “n”, “+”, “−”, etc.  
           [0018]    Therefore it is often necessary to cleanse a database at a regular interval of time to ensure consistency for each type of field. Cleansing is both a very time consuming and computationally heavy task, especially for large databases. Further, cleansing of a database may delete valuable information, since information may be hidden in the way different data is entered into the database. For example, if a field was to contain the value “Yes” or “No” reflecting an answer to “colored”, the entered data may be “green”, “blue” etc. During cleansing the information of the actual color will be lost and changed to “YES”.  
           [0019]    SQL only gives the possibility of ‘Categorical Query’, i.e. there has to be an exact match to provided search criteria in order to obtain a result, or a null result will be given.  
           [0020]    Even though fuzzy functions and phonetics are known in connection with databases it needs a dedicated driver; e.g. Oracle has some of this functionality in their “Stored Procedures”, which is dedicated to an Oracle database. Other database vendors have similar functionalities bound to their proprietary systems.  
         Solutions  
         [0021]    The object of the invention is to provide a method which enables a generic and more intelligent communication with one or more standard databases and a more intelligent handling of the data/values in the fields of the database(s). The database(s) may even be heterogeneous.  
           [0022]    This is achieved by a method of the said type  
           [0023]    the first processing is done by expanding the first query according to one or more query functions,  
           [0024]    the second processing is done by contracting the first result, and in that the method further comprises the step of F. calculating an overall score for one or more query functions according to a second function.  
           [0025]    Hereby, a method is provided where a generic ‘intercepting’ layer of functionality may be applied to incorporate many different functionalities between the user at one end and the database at the other. In this way, the user sees a ‘virtual database’ having the functionality which the generic and intercepting layer provides.  
           [0026]    The method is generic, since the functionality is transparent, i.e. intercepting, and builds on a standard query language.  
           [0027]    Additionally the method is able to handle lacking consistency in different fields of e.g. an SQL, database, thereby avoiding the need for cleansing.  
           [0028]    Additionally the method is able to sort the result of an SQL query, e.g. by ranking and indication of metric distance given by an overall score so that the most relevant information is presented first to the user.  
           [0029]    These features bring the quality of a search up to a higher level than possible in a standard SQL search.  
           [0030]    In accordance with an embodiment the database is a virtual database comprising one or more heterogeneous sources and/or homogenous sources. Theses sources may be standard databases or even file systems and other unstructured information sources.  
           [0031]    In this way a user only sees or experiences the communication with a collection of databases as communication with a single database and does not have to worry about or even know which data requested by him comes from which physical database. Additionally the user may request data from heterogeneous databases/sources. All that is needed is the implementation of corresponding query functions.  
           [0032]    In accordance with another embodiment the method is repeated until the overall score for all query functions satisfies a given criterion.  
           [0033]    Hereby, it is possible to expand the original query gradually, so that only the most relevant information is retrieved. If no result is returned, then the query can be expanded to search for values with differ more from the originally specified search value(s). This functionality will be denoted a ‘Query Manager’ in the following.  
           [0034]    In accordance with another embodiment the expanding of the first query for each repetition of the method is done according to only the query functions having an overall score which does not satisfy the given criteria.  
           [0035]    Hereby, only the parts of the originally expanded query not satisfying the given criteria have their distance to the specified search value(s) enlarged, which reduces the computational effort needed to bring all the overall scores for the query functions into satisfaction.  
           [0036]    In accordance with another embodiment the contracting of the first result by the second processing is done on the basis of the overall score for one or more query functions.  
           [0037]    In accordance with another embodiment the overall score for one or more query functions is calculated on the basis of one or more individual scores.  
           [0038]    In accordance with another embodiment the one or more individual scores are calculated as a metric distance representing how close instances of data in the first result are to the one or more search values.  
           [0039]    In accordance with another embodiment the one or more query functions execute one or more of the functions:  
           [0040]    automatic translation of words,  
           [0041]    conversion of values,  
           [0042]    fuzzy logic functions,  
           [0043]    personalising,  
           [0044]    security control functions.  
           [0045]    In this way it is possible to have query functions which can e.g. automatically convert words between one or more languages. For example all words contained in one or more databases may be translated into another language, e.g. from English into Danish.  
           [0046]    The query functions may also provide an automatic conversion of values. This avoids the need for cleansing of the database since fields having a format that differs can be converted by the intercepting layer/query functions and be presented to the user in a uniform way. For example “Y”, “y”, “+” and “N”, “n”, “−” may be converted into “Yes” and “No”, respectively.  
           [0047]    This enables intelligent handling of fields with contents that frequently vary, e.g. time, dates, etc.  
           [0048]    Another advantage is the possibility of being able to include fuzzy logic in an existing SQL database by using the query functions. This gives the advantage that e.g. if the user specifies a search value and that value is not present in any field in the database being searched, then the user can be presented with the value or values being closest to the specified search value. This is not possible in a standard SQL without any functional layer.  
           [0049]    Additionally functionality may be personalising and/or security control functions responding indirectly to input parameters from the user level or from an application handling the communication between the user and the database as well as receiving input and presenting results to the user.  
           [0050]    The above functionalities are only examples and in principle all kinds of different functionalities may be implemented.  
           [0051]    This together with the ‘Query Manager’ is a very useful feature, since the ‘Query Manager’ gives the possibility of repeated expansion/evaluation until a given criterion is met and/or a satisfactory result is obtained.  
           [0052]    For example, it is possible to ‘Query by example’, since a result can always be presented to the user, i.e. the result being closest to the specified search value, as opposed to a standard SQL database where a null result will be provided if a search value is not present in the database.  
           [0053]    Alternatively, the query functions of a layer may contain combinations of different types of functions so that both fuzzy logic and translation of words are provided, and etc.  
           [0054]    Another object of the present invention is to provide an apparatus which enables a more intelligent and generic communication with one or more standard databases and a more intelligent handling of the data/values in the fields of the database(s). The databases may even be heterogeneous.  
           [0055]    This object is achieved by an apparatus of the said type where  
           [0056]    the first processing is done by expanding the first query according to one or more query functions,  
           [0057]    the second processing is done by contracting the first result, and that  
           [0058]    an overall score is calculated for one or more query functions according to a second function.  
           [0059]    This gives the same advantages for the same reasons as described previously in relation to the method.  
           [0060]    Other embodiments of the apparatus according to the invention are characterized by the features defined in the dependent claims which are advantageous for the same reasons as described previously in relation to the method.  
           [0061]    Further, the invention relates to a computer-readable medium whose contents are adapted to cause a computer system to perform the method described above. A medium may e.g. be a CD-ROM, a floppy disk, a hard disk, a DVD RAM/ROM drive, a network, etc.  
           [0062]    Hereby, when a computer is caused to retrieve electronic information—as a consequence of the contents of a computer-readable medium as described above—the advantages mentioned in connection with the corresponding method according to the invention are achieved.  
           [0063]    Finally, the invention relates to a computer program element comprising program code means adapted to enable a computer system to perform the method described above.  
           [0064]    When a computer program element causes a computer to retrieve electronic information as described above, the advantages mentioned in connection with the corresponding method according to the invention are achieved. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0065]    The present invention will now be described more fully with reference to the drawings, in which  
         [0066]    [0066]FIG. 1 shows a flowchart according to one embodiment of the invention;  
         [0067]    [0067]FIG. 2 shows a fuzzy curve;  
         [0068]    [0068]FIG. 3 illustrates an example of how the Query Manager imposes constraints;  
         [0069]    [0069]FIG. 4 shows a schematic representation of the relationship between different query functions and a database;  
         [0070]    [0070]FIG. 5 illustrates a schematic block diagram of an apparatus according to one embodiment of the invention.  
     
    
     DETAILED DESCRIPTION  
       [0071]    [0071]FIG. 1 shows a flowchart according to one embodiment of the invention. In the following the method will only be described broadly and a more detailed description will be given later in connection with FIGS. 2, 3 and  4 .  
         [0072]    In step (101) a query statement specified by a user is ‘intercepted’ or received by an application using the method according to the invention. This query is expanded in step ( 102 ) according to one or more query functions/rules. Additionally one or more parameters may be specified, e.g. by the user and/or by the application, preferably for each query function together with the original query. An example of a parameter could e.g. be a minimum score for a value of a particular field. These parameters are used together with the query, resulting in one or more restrictions. The result and/or restrictions of each query function return a subpart query which is concatenated into the single expanded query.  
         [0073]    The expanded query statement is then sent to the database in step ( 103 ) and executed, which returns a search result in step ( 104 ) based on the expanded query. The search result consists of a number of rows which have fields fulfilling the expanded query.  
         [0074]    The search result is then evaluated in step ( 105  with respect to how well the returned result is in accordance with the original query. For example, a score for each function may be obtained, as will be described later in connection with FIG. 2.  
         [0075]    In step ( 106 ) it is determined whether the result is OK and thereby ready to be presented to the user. This functionality of checking whether another iteration of expansion and contraction of the query is needed, is denoted a ‘Query Manager’. If the result is OK then the result is sent and/or presented to the user in step ( 107 ), and if not then the method loops back to step ( 102 ) where another iteration of expansion, collection and scoring takes places.  
         [0076]    More specifically, if the scores for all query functions are not fulfilled, then the query functions which had non-fulfilled scores generate another sub-query which is expanded in a broader sense, e.g. the interval of values of interest may be expanded. So another expanded query comprising elements from the non-fulfilled query functions with broader values is executed in the database. This is done until all the query functions score sufficiently according to a given criterion, and the method will then proceed to step ( 107 ) and present the search result as mentioned earlier.  
         [0077]    The various query functions may include many different functions to be performed on the database. Each query function may be applied to only certain fields in the database. Examples of query functions include automatical translation of words from one language into another, conversion of values, fuzzy logic, etc.  
         [0078]    [0078]FIG. 2 shows a fuzzy curve ( 201 ). This figure will be used to describe an example of how one query function implementing fuzzy logic returns a subpart of the expanded query and how the obtained result is scored. As an example, the query function is chosen to be a fuzzy query function, associated with the logarithmic fuzzy curve ( 201 ), which provides a more intelligent handling of real numbers in a database.  
         [0079]    Shown is the logarithmic fuzzy curve ( 201 ) which gives the relationship between a real value q and the corresponding fuzzy score s. Also shown is a search value v ( 202 ) specified by the user in the original query together with qmin=v/w ( 203 ) and qmax=v*w ( 204 ). w (not shown) is the width of the fuzzy curve and defines the width of the fuzzy curve ( 201 ), i.e. for which values/interval of q around v we have a corresponding fuzzy score s different from zero. qmin ( 203 ) and qmax ( 204 ) in this way give the interval of values we find interesting.  
         [0080]    Given the search value v ( 202 ) and a minimum score Smin (between 0 and 1), e.g. specified by the user, we need to create a part of an SQL statement for returning all rows of a database table, which scores more than the Smin for a given fuzzy function.  
         [0081]    As the field to select in the SQL query we choose an SQL expression exp that returns the real value on which we would like to perform the search. In order to restrict the query we create a subpart of the SQL: &lt;exp&gt; BETWEEN &lt;a&gt; AND &lt;b&gt;, where a ( 205 ) and b ( 206 ) limit the interval of values we want to include in our search result. a ( 205 ) and b ( 206 ) are given by:  
         a   =       S                   min   ·   v       +       (     1   -     S                 min       )     ·     v   25     ·   w         ,     
          b   =       S                   min   ·   v       +       (     1   -     S                 min       )     ·       v   w     .                                 
 
         [0082]    Note that in the special cases where Smin=1 or Smin=0, then a=b=v or a=qmin and b=qmax, respectively.  
         [0083]    In this way the value of Smin defines the expansion of the interval in which we look for relevant values.  
         [0084]    After the query has been executed, a set of rows, each containing a field with a real value within the specified interval, fulfilling the query is returned. These real values for each row are then processed in order to obtain a score, S, for each of the rows. This score is a measure of how close the real value in a particular row is to the original search value v.  
         [0085]    The scoring is preferably:  
       S   =     {             v   -     q       v   ·   w     -   v         ,             if                 q     &gt;   v                 v   -     q       v   /   w     -   v         ,           otherwise   .                                   
 
         [0086]    This score, S, e.g. enables the presentation of retrieved rows from the database to be sorted according to which row has a real value which is closest to the specified search value.  
         [0087]    In this way fuzzy functions may be used to expand values. For example, the user may specify interest in a value of 100 and be presented with a search result containing fields in the interval of 90 to 110 sorted according to how close the fields are to the initial, specified value of 100, i.e. sorted according to their score.  
         [0088]    [0088]FIG. 3 illustrates an example of how the Query Manager gradually imposes different constraints on the expanded query. It is very useful to gradually broaden the interval of values which are retrieved by the method, i.e. to reduce the Smin (see FIG. 2). In this way it is possible, by evaluating a total score for each iteration of the Query Manager, to stop when interesting information/values have been retrieved without the inclusion of uninteresting noise in the form of fields containing a value that is very far from the original, specified search criteria.  
         [0089]    In this way we want to find the best n matches for a query by performing a number of queries starting with an exact match and ending with a very broad query. When each query function, e.g. fuzzy query function, is asked to construct an SQL query, it is given the minimum score Smin. The query function should then construct an SQL query which returns all the rows of the database table that have a score equal to or higher than the specified Smin. This process is done for each query function independent of each other. In this way the Query Manager expands the SQL query until it is guaranteed that the result contains the n best rows of the database table.  
         [0090]    The overall score of a row is calculated by the expression:  
         S   =     ∏       s   i     w   i          15         ,                         
 
         [0091]    where s i  ε [0;1] is the score of the i&#39;th query function, w i  ε [0;∞] is a weight number applied to the i&#39;th query function, and S is the overall score obtained by multiplying all the individual scores of each query function together.  
         [0092]    The restrictions given by the individual query functions form a ‘bounding box’ for the query in question. The result is found by expanding the overall minimum score and thereby the bounding box until the best n overall scores are greater than the given overall minimum score.  
         [0093]    As an example we assume that we execute a query using the following sequence of minimum overall scores: 
         S′=1.0; S′=0.8; S′=0.6; S′=0.4; S′=0.2;S′=0.0; 
         [0094]    Then the bounding box would increase in size as S′ gets smaller. S′=1.0 means that only rows with fields having values identical with the specified search number/keyword (see FIG. 2) are returned, and S′=0.0 means that all rows are returned.  
         [0095]    This process of a gradually expanding fuzzy search is illustrated in FIG. 3 where the diamonds ( 301 ) represent different rows in the database table, the circles ( 302 ) represent the distance of the field and the query, and the boxes ( 303 ) represent the ‘bounding boxes’ for each of the overall minimum scores S′.  
         [0096]    As can be seen in FIG. 3 no rows for S′=1.0 are returned. When the Query Manager receives no rows, it generates another expanded query with S′=0.8 which does not return any rows either. For S′=0.6 two rows ( 304  and  305 ) are returned which both have the same distance as illustrated by the bounding box ( 306 ). This procedure is repeated until all the interesting rows are returned either by S′=0.0 or by a given criterion, e.g. specified by the user or internally by the method. Such a criterion may be a metric distance of e.g. 5%, 10%, etc.  
         [0097]    [0097]FIG. 4 shows a schematic representation of the relationship between different query functions and a database. Shown is the intercepting layer ( 401 ) of query functions ( 402 ). In this example eight different query functions ( 402 ) are shown, each providing different functionalities.  
         [0098]    The query functions ( 402 ) receive/intercept the original query e.g. together with additional parameters ( 403 ) specified by the user or internally by an application. These additional parameters ( 403 ) may be maximum metric distance, maximum number of returned rows, etc.  
         [0099]    After receiving the original query, each query function ( 402 ) generates an expanded sub SQL statement according to that particular query function and parameters, if any. The expanded sub statement relates to one or more fields ( 404 ) in the database ( 405 ) as indicated by the arrows ( 406 ) pointing from the query functions ( 402 ) to the database ( 405 ) in FIG. 4. The fields ( 404 ) to which a given query function relates may e.g. be predefined or dependent on the parameters ( 403 ). All these SQL statements from each query function are then concatenated into a single expanded SQL statement, which is executed in the database ( 405 ), and a search result containing rows ( 407 ) with fields ( 404 ) fulfilling the expanded query is returned.  
         [0100]    The search result is sent back to the intercepting/receiving layer ( 401 ) where each query function ( 402 ) receives the values each particular query function ( 402 ) was responsible for selecting. If two or more query functions ( 402 ) both selected a specific field, the value of that field is returned to both query functions ( 403 ).  
         [0101]    After the query functions ( 402 ) have received the values from the database ( 405 ) a scoring of the result is executed by a Score Calculator ( 408 ) as described in connection with FIG. 2.  
         [0102]    If the scoring for a given query function ( 402 ) is sufficient, then the result of that query function ( 402 ) is ready to be presented to the user. If the scoring for a given query function ( 402 ) is not sufficient, then another iteration may be performed by the Query Manager where a new sub SQL statement is created with gradually fewer and/or looser constraints. All the new sub SQL statements for each query function ( 402 ) which did not score sufficiently are concatenated into a new expanded query, which is executed in the database. This procedure is repeted until every query function ( 402 ) scores sufficiently.  
         [0103]    When all scores are satisfactory, the result of each query function ( 403 ) is contracted into a single search result, which is presented to the user.  
         [0104]    The user perceives this single result as the result on the basis of the original query and does not have to know of the functionality in the intercepting/receiving layer ( 401 ). That is, the user sees a virtual database with the functionality provided by the query functions ( 402 ).  
         [0105]    The query functions ( 402 ) may implement all kinds of different functionality and may be set to perform exactly as desired. For example, the query functions ( 402 ) may respond to input parameters ( 402 ) from the user level or from an application handling the communication between the user and the database as well as receiving input and presenting results to the user. In this way the query functions ( 402 ) may work as personalisers, security functions, etc.  
         [0106]    A personalising part may e.g. be implemented by using an input consisting of a personal profile and using this profile to contribute to the total score in the Score Calculator ( 408 ), e.g. by modifying weights, w i , in the individual scoring functions as described in connection with FIG. 2. If the results found are not within the personal profile they will be scored very low and thereby not be relevant as such.  
         [0107]    A security function may be implemented in a similar way, since fields or results not accessible to the user will score too low to match.  
         [0108]    In an alternative embodiment the intercepting/receiving layer ( 401 ) is connected to two or more databases.  
         [0109]    [0109]FIG. 5 illustrates a schematic block diagram of an apparatus according to one embodiment of the invention. Shown here are processing means ( 502 ) which may be any kind of a CPU. The processing means ( 502 ) are connected to receiving means ( 501 ) which are responsible for receiving information from other units outside the apparatus. This information may e.g. be data from a database ( 504 ) or input directly by a user, e.g. by mouse and keyboard or the like, or from another (server/client) application e.g. providing a graphical interface to the user and/or handling the exchange of information in a network. The database ( 504 ) may be a locally or externally stored database. Alternatively the database ( 504 ) may comprise one or more heterogeneous and/or homogeneous databases which the user, through the functionality of the layer, may perceive as one single database. In this way data from many different databases may be accessed by one query if query functions are specified which handle this situation properly. So the user does not have to think about which databases contain which data when he specifies a query.  
         [0110]    The processing means ( 502 ) are also connected to storing means ( 506 ) for storage and later retrieval of results, variables, etc. The storing means ( 506 ) may be any kind of RAM, hard disk, etc. (preferably a combination).  
         [0111]    The processing means ( 502 ) are additionally connected to executing means ( 503 ) which are responsible for executing the query expanded by the processing means ( 502 ) in one or more databases ( 504 ). In a preferred embodiment the processing means ( 502 ) and the executing means ( 503 ) are formed by a single CPU means ( 500 ).  
         [0112]    The processing means ( 502 ) are also connected to sending/presenting means ( 507 ), e.g. a display, for displaying information, choices, results, etc. to a user, or for sending the result(s) of a query to another application which may be responsible for presenting the result(s) to a user and/or long-time storage, etc.  
         [0113]    The processing means ( 403 ) are responsible for the execution of a program which enables the expansion of a query according to one or more query functions, the expanded query being executed in one or more databases ( 504 ) instead of the original query. The query functions provide the possibility of implementing different functionalities like fuzzy functions, etc. into a standard database ( 504 ) transparently to the user.  
         [0114]    After the expanded query has been executed by the executing means ( 503 ) in the database ( 504 ) the receiving means ( 510 ) receive a result of the expanded query. The result is a number of rows which fulfil the expanded query. The result is then sent to the processing means ( 502 ) where a score for each query functions is provided. If not all scores satisfy a given criterion, a new expanded query is generated which is then executed in the database ( 504 ).  
         [0115]    This is repeated until all the scores are satisfactory, and then the result is presented to the user or sent to another application via the sending/presenting means ( 507 ).