[Javamatch-cvs] javamatch/docs/website javamatch.xml,1.5,1.6

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/javamatch/javamatch/docs/website
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30474

Modified Files:
	javamatch.xml 
Log Message:
Added chapter about results to car example, some other stuff

Index: javamatch.xml
===================================================================
RCS file: /cvsroot/javamatch/javamatch/docs/website/javamatch.xml,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** javamatch.xml	9 Sep 2004 14:19:50 -0000	1.5
--- javamatch.xml	10 Sep 2004 12:58:27 -0000	1.6
***************
*** 8,24 ****
      generic match engine, not targeted at a specific domain. It can be applied to any 
      runtime data structure, and the extensive query mechanism allows for highly 
!     customizable tuning of your searches.
! </p>
! <p>
!     In other words, JavaMatch provides a superset of search engine-like functionality 
!     to your data structures. It allows for more vague searches than SQL SELECT queries, 
!     can be applied to any java data structure, and is accessible via a Java-only API.
  </p>
! <p>
!     JavaMatch will be integrated with object-relational mapping tools, such as 
!     Hibernate and JDO. This allows to matching within databases. Integration 
!     with JDO is planned for release 0.2
  </p>
! <h2>Example 1: Simple query</h2>
      <p>
      Nice those stories, but how does it work in practice? Let me give you an example:
--- 8,27 ----
      generic match engine, not targeted at a specific domain. It can be applied to any 
      runtime data structure, and the extensive query mechanism allows for highly 
!     customizable tuning of your searches. JavaMatch can be integrated with object-
!     relational mapping tools. This allows you to match inside databases.
  </p>
! <h3>Functionality</h3>
! <p> JavaMatch's functionality compared to "normal" database searching can be described 
!     by using an analogy:</p>
! <p class="example">
!     If you search for something in Google, you don't just see the pages that <b>exactly</b> 
!     match your search query, you'll also get the results that <b>best</b> match the search 
!     query (unless you use the "+"-syntax).<br/>
!     JavaMatch provides this Google-like functionality, but then applied to a Java data 
!     structure: It looks for the objects that <b>best</b> match the query: Out of the 
!     entire data set, it returns the top-10 (or more, if you specify so) of the best 
!     matching objects.
  </p>
! <h2>Example 1: Queries</h2>
      <p>
      Nice those stories, but how does it work in practice? Let me give you an example:
***************
*** 41,47 ****
  List campSites = guide.getCampSites();
  MatchResult matchResult = matchEngine.executeQuery(query, campSites);</pre>
- <p><b><i>
- Note: the syntax for retrieval of data members (such as "size") will change in version 0.2
- </i></b></p>
  <p>
      Class MatchResult contains a list of ResultItem's. A ResultItem consists of a
--- 44,47 ----
***************
*** 54,60 ****
      The full source can be found in the directory examples/camping in the distribution
  </p>
! <h2>Example 2: Extension</h2>
      <p>
!     The JavaMatch engine is domain-indepentent, so if I want to look for a certain 
      second-hand car, I can specify the following query:
      </p>
--- 54,60 ----
      The full source can be found in the directory examples/camping in the distribution
  </p>
! <h2>Example 2: Results and extensions</h2>
      <p>
!     The JavaMatch engine is domain-independent, so if I want to look for a certain 
      second-hand car, I can specify the following query:
      </p>
***************
*** 67,71 ****
  List allCars = carData.getAllCars();
  MatchResult matchResult = matchEngine.executeQuery(query, allCars);</pre>
!     <p>
      You may want to find a match with more complicated, domain-specific criteria, 
      for example if the car has had regular service intervals. In this case, you can 
--- 67,136 ----
  List allCars = carData.getAllCars();
  MatchResult matchResult = matchEngine.executeQuery(query, allCars);</pre>
! <hr/>
! <h3>Results</h3>
! <p>
! When you execute this query, the match engine might return objects with the 
! following data:
! </p>
! <table class= "enum">
!  <tr>
!   <th>Match value</th>
!   <th>brand</th>
!   <th>buildYear</th>
!   <th>price</th>
!   <th>mileage</th>
!  </tr>
!  <tr>
!   <td>1.00</td>
!   <td>BMW</td>
!   <td>1998</td>
!   <td>$7,900.00</td>
!   <td>44,000</td>
!  </tr>
!  <tr>
!   <td>1.00</td>
!   <td>BMW</td>
!   <td>2002</td>
!   <td>$9,999.00</td>
!   <td>25,000</td>
!  </tr>
!  <tr>
!   <td>1.00</td>
!   <td>BMW</td>
!   <td>1997</td>
!   <td>$6,400.00</td>
!   <td>62,000</td>
!  </tr>
!  <tr>
!   <td>0.75</td>
!   <td>BMW</td>
!   <td>2002</td>
!   <td><b><i>$13,000.00</i></b></td>
!   <td>35,000</td>
!  </tr>
!  <tr>
!   <td>0.75</td>
!   <td><b><i>Alpha Romeo</i></b></td>
!   <td>2000</td>
!   <td>$7,800.00</td>
!   <td>55,000</td>
!  </tr>
!  <tr>
!   <td>0.50</td>
!   <td>BMW</td>
!   <td><b><i>2003</i></b></td>
!   <td><b><i>$15,500.00</i></b></td>
!   <td>12,000</td>
!  </tr>
! </table>
! <p>
!     As you can see in row 1 to 3, the match engine first returns the objects that 
!     exactly match the criteria. This is similar to the rows you'll get when you
!     execute an SQL query. Row 4 to 6 are different: they show the objects that 
!     don't match <b>exactly</b>, but the objects that <b>best</b> match the query.
! </p>
! <hr/>
! <h3>Extensions</h3>
! <p>
      You may want to find a match with more complicated, domain-specific criteria, 
      for example if the car has had regular service intervals. In this case, you can 
***************
*** 137,141 ****
  </page>
  <page title="FAQ" filebase="faq">
! <h2>"What is JavaMatch, compared to..."</h2>
  <h3>What is JavaMatch, compared to a search engine?</h3>
  <p>            
--- 202,206 ----
  </page>
  <page title="FAQ" filebase="faq">
! <h2>What is JavaMatch, compared to...</h2>
  <h3>What is JavaMatch, compared to a search engine?</h3>
  <p>            
***************
*** 154,158 ****
  </p>
  <h3>What is JavaMatch, compared to SQL?</h3>
! <p>If you compare the functionality of JavaMatch with SQL, you'll see two big 
  differences:
  <ul>
--- 219,223 ----
  </p>
  <h3>What is JavaMatch, compared to SQL?</h3>
! <p>If you compare the functionality of JavaMatch with SQL, you'll see a couple of
  differences:
  <ul>
***************
*** 162,165 ****
--- 227,235 ----
  objects <b>best</b> match your query, and returns their top 10, in ascending 
  order</li>
+ <li>SQL has a limited set of query operators, JavaMatch's queries can be extended
+ to target a specific domain</li>
+ <li>SQL executes the query inside the database, and returns the results. JavaMatch 
+ retrieves all data from the underlying data storage mechanism, and performs the 
+ matching in the Java runtime environment</li>
  </ul>
  </p>
***************
*** 171,175 ****
  optimized better.
  </p>
! <h2>"How, when and where to use"</h2>
  <h3>Why hasn't this been implemented before?</h3>
  <p>Usually, large amounts of data are kept in a database instead of in memory 
--- 241,245 ----
  optimized better.
  </p>
! <h2>How, when and where to use</h2>
  <h3>Why hasn't this been implemented before?</h3>
  <p>Usually, large amounts of data are kept in a database instead of in memory 
***************
*** 196,200 ****
              causes less overhead.
  </p>
! <h2>"Usage"</h2>
  <h3>I get very little results. What's wrong?</h3>
  <p>
--- 266,270 ----
              causes less overhead.
  </p>
! <h2>Usage</h2>
  <h3>I get very little results. What's wrong?</h3>
  <p>
***************
*** 343,347 ****
          <ul>
          <li>Better syntax for following and constraining object references, 
!         handle collections</li>
          </ul>
          </td>
--- 413,421 ----
          <ul>
          <li>Better syntax for following and constraining object references, 
!         handle collections.<br/>
!         For example: "Has a" and "sum"-operators on collections (A resume that 
!         contains at least one project related to car manufacturing, or the sum 
!         of the duration of all projects that had something to do with Java 
!         technology)</li>
          </ul>
          </td>
***************
*** 369,372 ****
--- 443,450 ----
      </tr>
      <tr>
+         <td>20040910</td>
+         <td>Updated car example-results and FAQ-SQL</td>
+     </tr>
+     <tr>
          <td>20040909</td>
          <td>Added NotQuery, listener mechanism, added FAQ contents, fixed