PK &Aoa,mimetypeapplication/epub+zipPK&AiTunesMetadata.plistO artistName Oracle Corporation book-info cover-image-hash 511215841 cover-image-path OEBPS/dcommon/oracle-logo.jpg package-file-hash 260479264 publisher-unique-id E24435-01 unique-id 458236855 genre Oracle Documentation itemName Oracle® Text Application Developer's Guide, 11g Release 2 (11.2) releaseDate 2011-07-27T18:47:41Z year 2011 PK;/TOPK&AMETA-INF/container.xml PKYuPK&AOEBPS/classify.htm Classifying Documents in Oracle Text

6 Classifying Documents in Oracle Text

This chapter includes the following topics:

6.1 Overview of Document Classification

A major problem facing businesses and institutions today is that of information overload. Sorting out useful documents from documents that are not of interest challenges the ingenuity and resources of both individuals and organizations.

One way to sift through numerous documents is to use keyword search engines. However, keyword searches have limitations. One major drawback is that keyword searches do not discriminate by context. In many languages, a word or phrase may have multiple meanings, so a search may result in many matches that are not on the desired topic. For example, a query on the phrase river bank might return documents about the Hudson River Bank & Trust Company, because the word bank has two meanings.

An alternative strategy is to have human beings sort through documents and classify them by content, but this is not feasible for very large volumes of documents.

Oracle Text offers various approaches to document classification. Under rule-based classification, you write the classification rules yourself. With supervised classification, Oracle Text creates classification rules based on a set of sample documents that you pre-classify. Finally, with unsupervised classification (also known as clustering), Oracle Text performs all the steps, from writing the classification rules to classifying the documents, for you.

6.1.1 Classification Applications

Oracle Text enables you to build document classification applications. A document classification application performs some action based on document content. Actions include assigning category IDs to a document for future lookup or sending a document to a user. The result is a set or stream of categorized documents. Figure 6-1 illustrates how the classification process works.

Oracle Text enables you to create document classification applications in different ways. This chapter defines a typical classification scenario and shows how you can use Oracle Text to build a solution.

Figure 6-1 Overview of a Document Classification Application

Description of Figure 6-1 follows
Description of "Figure 6-1 Overview of a Document Classification Application"

6.2 Classification Solutions

Oracle Text enables you to classify documents in the following ways:

6.3 Rule-Based Classification

Rule-based classification (sometimes called "simple classification") is the basic way of creating an Oracle Text classification application.

The basic steps for rule-based classification are as follows. Specific steps are explored in greater detail in the example.

  1. Create a table for the documents to be classified, and populate it.

  2. Create a rule table (also known as a category table). The rule table consists of categories that you name, such as "medicine" or "finance," and the rules that sort documents into those categories.

    These rules are actually queries. For example, you might define the "medicine" category as consisting of documents that include the words "hospital," "doctor," or "disease," so you would set up a rule of the form "hospital OR doctor OR disease." See "CTXRULE Parameters and Limitations" for information on which operators are allowed for queries.

  3. Create a CTXRULE index on the rule table.

  4. Classify the documents.

6.3.1 Rule-based Classification Example

In this example, we gather news articles on different subjects and then classify them.

Once our rules are created, we can index them and then use the MATCHES statement to classify documents. The steps are as follows:

Step 1   Create schema

We create the tables to store the data. The news_table stores the documents to be classified. The news_categories table stores the categories and rules that define our categories. The news_id_cat table stores the document ids and their associated categories after classification.

create table news_table (
       tk number primary key not null,
       title varchar2(1000),
       text clob);

create table news_categories (
        queryid  number primary key not null,
        category varchar2(100),
        query    varchar2(2000));

create table news_id_cat (
        tk number, 
        category_id number);
Step 2   Load Documents with SQLLDR

In this step, we load the HTML news articles into the news_table using the SQLLDR program. The filenames and titles are read from loader.dat.

LOAD DATA
     INFILE 'loader.dat'
     INTO TABLE news_table
     REPLACE
     FIELDS TERMINATED BY ';'
     (tk         INTEGER EXTERNAL,
      title      CHAR,
      text_file  FILLER CHAR,
      text       LOBFILE(text_file) TERMINATED BY EOF)
Step 3   Create Categories

In this step, we define our categories and write the rules for each of our categories.

Defined Categories:

United StatesEuropeMiddle East
AsiaAfricaConflicts
FinanceTechnologyConsumer Electronics
Latin AmericaWorld PoliticsU.S. Politics
AstronomyPaleontologyHealth
Natural DisastersLawMusic News

A rule is a query that selects documents for the category. For example, the category 'Asia' has a rule of 'China or Pakistan or India or Japan'. We insert our rules in the news_categories table as follows:

insert into news_categories values
  (1,'United States','Washington or George Bush or Colin Powell');

insert into news_categories values
  (2,'Europe','England or Britain or Germany');

insert into news_categories values
  (3,'Middle East','Israel or Iran or Palestine');

insert into news_categories values(4,'Asia','China or Pakistan or India or Japan');

insert into news_categories values(5,'Africa','Egypt or Kenya or Nigeria');

insert into news_categories values
  (6,'Conflicts','war or soliders or military or troops');

insert into news_categories values(7,'Finance','profit or loss or wall street');
insert into news_categories values
  (8,'Technology','software or computer or Oracle 
   or Intel or IBM or Microsoft');

insert into news_categories values
  (9,'Consumer electronics','HDTV or electronics');

insert into news_categories values
  (10,'Latin America','Venezuela or Colombia 
   or Argentina or Brazil or Chile');

insert into news_categories values
  (11,'World Politics','Hugo Chavez or George Bush 
   or Tony Blair or Saddam Hussein or United Nations');

insert into news_categories values
  (12,'US Politics','George Bush or Democrats or Republicans 
   or civil rights or Senate or White House');

insert into news_categories values
  (13,'Astronomy','Jupiter or Earth or star or planet or Orion 
   or Venus or Mercury or Mars or Milky Way 
   or Telescope or astronomer 
   or NASA or astronaut');

insert into news_categories values
  (14,'Paleontology','fossils or scientist 
   or paleontologist or dinosaur or Nature');

insert into news_categories values
  (15,'Health','stem cells or embryo or health or medical
   or medicine or World Health Organization or AIDS or HIV 
   or virus or centers for disease control or vaccination');

insert into news_categories values
  (16,'Natural Disasters','earthquake or hurricane or tornado');

insert into news_categories values
  (17,'Law','abortion or Supreme Court or illegal 
   or legal or legislation');

insert into news_categories values
  (18,'Music News','piracy or anti-piracy 
   or Recording Industry Association of America 
   or copyright or copy-protection or CDs 
   or music or artist or song');

commit;
Step 4   Create the CTXRULE index

In this step, we create a CTXRULE index on our news_categories query column.

create index news_cat_idx on news_categories(query)
indextype is ctxsys.ctxrule;
Step 5   Classify Documents

To classify the documents, we use the CLASSIFIER.THIS PL/SQL procedure (a simple procedure designed for this example), which scrolls through the news_table, matches each document to a category, and writes the categorized results into the news_id_cat table.

create or replace package classifier asprocedure this;end;/

show errors

create or replace package body classifier as

 procedure this
 is
  v_document    clob;
  v_item        number;
  v_doc         number;
 begin

  for doc in (select tk, text from news_table)
     loop
        v_document := doc.text;
        v_item := 0;
        v_doc  := doc.tk;
        for c in (select queryid, category from news_categories
             where matches(query, v_document) > 0 )
          loop
            v_item := v_item + 1;
            insert into news_id_cat values (doc.tk,c.queryid);
          end loop;
   end loop;

 end this;

end;
/
show errors
exec classifier.this

6.3.2 CTXRULE Parameters and Limitations

The following considerations apply to indexing a CTXRULE index.

  • If the SVM_CLASSIFIER classifier is used, then you may use the BASIC_LEXER, CHINESE_LEXER, JAPANESE_LEXER, or KOREAN_MORPH_LEXER lexers. If SVM_CLASSIFIER is not used, only the BASIC_LEXER lexer type may be used for indexing your query set. (See Oracle Text Reference for more on lexer and classifier preferences.)

  • Filter, memory, datastore, and [no]populate parameters are not applicable to index type CTXRULE.

  • The CREATE INDEX storage clause is supported for creating the index on the queries.

  • Wordlists are supported for stemming operations on your query set.

  • Queries for CTXRULE are similar to those of CONTAINS queries. Basic phrasing ("dog house") is supported, as are the following CONTAINS operators: ABOUT, AND, NEAR, NOT, OR, STEM, WITHIN, and THESAURUS. Section groups are supported for using the MATCHES operator to classify documents. Field sections are also supported; however, CTXRULE does not directly support field queries, so you must use a query rewrite on a CONTEXT query.


See Also:

"Creating a CTXRULE Index"

6.4 Supervised Classification

With supervised classification, you employ the CTX_CLS.TRAIN procedure to automate the rule writing step. CTX_CLS.TRAIN uses a training set of sample documents to deduce classification rules. This is the major advantage over rule-based classification, in which you must write the classification rules.

However, before you can run the CTX_CLS.TRAIN procedure, you must manually create categories and assign each document in the sample training set to a category. See Oracle Text Reference for more information on CTX_CLS.TRAIN.

When the rules are generated, you index them to create a CTXRULE index. You can then use the MATCHES operator to classify an incoming stream of new documents.

You may choose between two different classification algorithms for supervised classification:

6.4.1 Decision Tree Supervised Classification

To use Decision Tree classification, you set the preference argument to CTX_CLS.TRAIN to RULE_CLASSIFIER.

This form of classification uses a decision tree algorithm for creating rules. Generally speaking, a decision tree is a method of deciding between two (or more, but usually two) choices. In document classification, the choices are "the document matches the training set" or "the document does not match the training set."

A decision tree has a set of attributes that can be tested. In this case, these include:

  • words from the document

  • stems of words from the document (as an example, the stem of running is run)

  • themes from the document (if themes are supported for the language in use)

The learning algorithm in Oracle Text builds one or more decision trees for each category provided in the training set. These decision trees are then coded into queries suitable for use by a CTXRULE index. As a trivial example, if one category is provided with a training document that consists of "Japanese beetle" and another category with a document reading "Japanese currency," the algorithm may create decision trees based on the words "Japanese," "beetle," and "currency," and classify documents accordingly.

The decision trees include the concept of confidence. Each rule that is generated is allocated a percentage value that represents the accuracy of the rule, given the current training set. In trivial examples, this accuracy is almost always 100%, but this merely represents the limitations of the training set. Similarly, the rules generated from a trivial training set may seem to be less than what you might expect, but these are sufficient to distinguish the different categories given the current training set.

The advantage of the Decision Tree method is that it can generate rules that are easily inspected and modified by a human. Using Decision Tree classification makes sense when you want to the computer to generate the bulk of the rules, but you want to fine tune them afterward by editing the rule sets.

6.4.1.1 Decision Tree Supervised Classification Example

The following SQL example steps through creating your document and classification tables, classifying the documents, and generating the rules. It then goes on to generate rules with CTX_CLS.TRAIN.

Rules are then indexed to create CTXRULE index and new documents are classified with MATCHES.

The general steps for supervised classification can be broken down as follows:

6.4.1.1.1 Create the Category Rules

The CTX_CLS.TRAIN procedure requires an input training document set. A training set is a set of documents that have already been assigned a category.

Step 1   Create and populate a training document table

Create and load a table of training documents. This example uses a simple set; three concern fast food and three concern computers.

create table docs (
  doc_id number primary key,
  doc_text   clob);

insert into docs values
(1, 'MacTavishes is a fast-food chain specializing in burgers, fries and -
shakes. Burgers are clearly their most important line.');
insert into docs values
(2, 'Burger Prince are an up-market chain of burger shops, who sell burgers -
and fries in competition with the likes of MacTavishes.');
insert into docs values
(3, 'Shakes 2 Go are a new venture in the low-cost restaurant arena, 
specializing in semi-liquid frozen fruit-flavored vegetable oil products.');
insert into docs values
(4, 'TCP/IP network engineers generally need to know about routers, 
firewalls, hosts, patch cables networking etc');
insert into docs values
(5, 'Firewalls are used to protect a network from attack by remote hosts,
 generally across TCP/IP');
Step 2   Create category tables, category descriptions and ids
----------------------------------------------------------------------------

-- Create category tables
-- Note that "category_descriptions" isn't really needed for this demo -
-- it just provides a descriptive name for the category numbers in
-- doc_categories
----------------------------------------------------------------------------

create table category_descriptions (
  cd_category    number,
  cd_description varchar2(80));

create table doc_categories (
  dc_category    number,
  dc_doc_id      number,
  primary key (dc_category, dc_doc_id)) 
  organization index;

-- descriptons for categories

insert into category_descriptions values (1, 'fast food');
insert into category_descriptions values (2, 'computer networking');
Step 3   Assign each document to a category

In this case, the fast food documents all go into category 1, and the computer documents into category 2.

insert into doc_categories values (1, 1);
insert into doc_categories values (1, 2);
insert into doc_categories values (1, 3);
insert into doc_categories values (2, 4);
insert into doc_categories values (2, 5);
Step 4   Create a CONTEXT index to be used by CTX_CLS.TRAIN

Create an Oracle Text preference for the index. This enables us to experiment with the effects of turning themes on and off:

exec ctx_ddl.create_preference('my_lex', 'basic_lexer');
exec ctx_ddl.set_attribute    ('my_lex', 'index_themes', 'no');
exec ctx_ddl.set_attribute    ('my_lex', 'index_text',   'yes');

create index docsindex on docs(doc_text) indextype is ctxsys.context
parameters ('lexer my_lex');
Step 5   Create the rules table

Create the table that will be populated by the generated rules.

create table rules(
  rule_cat_id     number,
  rule_text       varchar2(4000),
  rule_confidence number
);
Step 6   Call CTX_CLS.TRAIN procedure to generate category rules

Now call the CTX_CLS.TRAIN procedure to generate some rules. Note all the arguments are the names of tables, columns or indexes previously created in this example. The rules table now contains the rules, which you can view.

begin
  ctx_cls.train(
    index_name => 'docsindex',
    docid      => 'doc_id',
    cattab     => 'doc_categories',
    catdocid   => 'dc_doc_id',
    catid      => 'dc_category',
    restab     => 'rules',
    rescatid   => 'rule_cat_id',
    resquery   => 'rule_text',
    resconfid  => 'rule_confidence'
  );
end;
/
Step 7   Fetch the generated rules, viewed by category

Fetch the generated rules. For convenience's sake, the rules table is joined with category_descriptions so we can see to which category each rule applies:

select cd_description, rule_confidence, rule_text from rules, 
category_descriptions where cd_category = rule_cat_id;
6.4.1.1.2 Index Rules to Categorize New Documents

Once the rules are generated, you can test them by first indexing them and then using MATCHES to classify new documents. The process is as follows:

Step 1   Index the rules to create the CTXRULE index

Use CREATE INDEX to create the CTXRULE index on the previously generated rules:

create index rules_idx on rules (rule_text) indextype is ctxsys.ctxrule;
Step 2   Test an incoming document using MATCHES
set serveroutput on;

declare
   incoming_doc clob;
begin
   incoming_doc 
       := 'I have spent my entire life managing restaurants selling burgers';
   for c in 
     ( select distinct cd_description from rules, category_descriptions
       where cd_category = rule_cat_id
       and matches (rule_text, incoming_doc) > 0) loop
     dbms_output.put_line('CATEGORY: '||c.cd_description);
   end loop;
end;
/

6.4.2 SVM-Based Supervised Classification

The second method we can use for training purposes is known as Support Vector Machine (SVM) classification. SVM is a type of machine learning algorithm derived from statistical learning theory. A property of SVM classification is the ability to learn from a very small sample set.

Using the SVM classifier is much the same as using the Decision Tree classifier, with the following differences.

  • The preference used in the call to CTX_CLS.TRAIN should be of type SVM_CLASSIFIER instead of RULE_CLASSIFIER. (If you do not want to modify any attributes, you can use the predefined preference CTXSYS.SVM_CLASSIFIER.)

  • The CONTEXT index on the table does not have to be populated; that is, you can use the NOPOPULATE keyword. The classifier uses it only to find the source of the text, by means of datastore and filter preferences, and to determine how to process the text, through lexer and sectioner preferences.

  • The table for the generated rules must have (as a minimum) these columns:

    cat_id      number,
type        number,
rule        blob );

As you can see, the generated rule is written into a BLOB column. It is therefore opaque to the user, and unlike Decision Tree classification rules, it cannot be edited or modified. The trade-off here is that you often get considerably better accuracy with SVM than with Decision Tree classification.

With SVM classification, allocated memory has to be large enough to lo(oad the SVM model; otherwise, the application built on SVM will incur an out-of-memory error. Here is how to calculate the memory allocation:

Minimum memory request (in bytes) = number of unique categories x number of features 
                                    example: (value of MAX_FEATURES attributes) x 8

If necessary to meet the minimum memory requirements, either:

  • increase SGA memory (if in shared server mode)

  • increase PGA memory (if in dedicated server mode)

6.4.2.1 SVM-Based Supervised Classification Example

The following example uses SVM-based classification. It uses essentially the same steps as the Decision Tree example. Some differences between the examples:

  • In this example, we set the SVM_CLASSIFIER preference with CTX_DDL.CREATE_PREFERENCE rather than setting it in CTX_CLS.TRAIN. (You can do it either way.)

  • In this example, our category table includes category descriptions, unlike the category table in the Decision Tree example. (You can do it either way.)

  • CTX_CLS.TRAIN takes fewer arguments than in the Decision Tree example, as rules are opaque to the user.

Step 1   Create and populate the training document table:
create table doc (id number primary key, text varchar2(2000));
insert into doc values(1,'1 2 3 4 5 6');
insert into doc values(2,'3 4 7 8 9 0');
insert into doc values(3,'a b c d e f');
insert into doc values(4,'g h i j k l m n o p q r');
insert into doc values(5,'g h i j k s t u v w x y z');
Step 2   Create and populate the category table:
create table testcategory (
        doc_id number, 
        cat_id number, 
        cat_name varchar2(100)
         );
insert into testcategory values (1,1,'number');
insert into testcategory values (2,1,'number');
insert into testcategory values (3,2,'letter');
insert into testcategory values (4,2,'letter');
insert into testcategory values (5,2,'letter');
Step 3   Create the CONTEXT index on the document table:

In this case, we create the index without populating.

create index docx on doc(text) indextype is ctxsys.context 
       parameters('nopopulate');
Step 4   Set SVM_CLASSIFIER:

This can also be done in CTX.CLS_TRAIN.

exec ctx_ddl.create_preference('my_classifier','SVM_CLASSIFIER'); 
exec ctx_ddl.set_attribute('my_classifier','MAX_FEATURES','100');
Step 5   Create the result (rule) table:
create table restab (
  cat_id number,
  type number(3) not null,
  rule blob
 );
Step 6   Perform the training:
exec ctx_cls.train('docx', 'id','testcategory','doc_id','cat_id',
     'restab','my_classifier');
Step 7   Create a CTXRULE index on the rules table:
exec ctx_ddl.create_preference('my_filter','NULL_FILTER');
create index restabx on restab (rule) 
       indextype is ctxsys.ctxrule 
       parameters ('filter my_filter classifier my_classifier');

Now we can classify two unknown documents:

select cat_id, match_score(1) from restab 
       where matches(rule, '4 5 6',1)>50;

select cat_id, match_score(1) from restab 
       where matches(rule, 'f h j',1)>50;

drop table doc;
drop table testcategory;
drop table restab;
exec ctx_ddl.drop_preference('my_classifier');
exec ctx_ddl.drop_preference('my_filter');

6.5 Unsupervised Classification (Clustering)

With Rule-Based Classification, you write the rules for classifying documents yourself. With Supervised Classification, Oracle Text writes the rules for you, but you must provide a set of training documents that you pre-classify. With unsupervised classification (also known as clustering), you do not even have to provide a training set of documents.

Clustering is performed with the CTX_CLS.CLUSTERING procedure. CTX_CLS.CLUSTERING creates a hierarchy of document groups, known as clusters, and, for each document, returns relevancy scores for all leaf clusters.

For example, suppose that you have a large collection of documents concerning animals. CTX_CLS.CLUSTERING might create one leaf cluster about dogs, another about cats, another about fish, and a fourth cluster about bears. (The first three might be grouped under a node cluster concerning pets.) Suppose further that you have a document about one breed of dogs, such as chihuahuas. CTX_CLS.CLUSTERING would assign the dog cluster to the document with a very high relevancy score, while the cat cluster would be assigned with a lower score and the fish and bear clusters with still lower scores. When scores for all clusters have been assigned to all documents, an application can then take action based on the scores.

As noted in "Decision Tree Supervised Classification", attributes used for determining clusters may consist of simple words (or tokens), word stems, and themes (where supported).

CTX_CLS.CLUSTERING assigns output to two tables (which may be in-memory tables):

CTX_CLS.CLUSTERING employs a K-MEAN algorithm to perform clustering. Use the KMEAN_CLUSTERING preference to determine how CTX_CLS.CLUSTERING works.


See Also:

Oracle Text Reference for more on cluster types and hierarchical clustering

6.5.1 Clustering Example

The following SQL example creates a small collection of documents in the collection table and creates a CONTEXT index. It then creates a document assignment and cluster description table, which are populated with a call to the CLUSTERING procedure. The output would then be viewed with a select statement:

set serverout on

/* collect document into a table */
create table collection (id number primary key, text varchar2(4000));
insert into collection values (1, 'Oracle Text can index any document or textual content.');
insert into collection values (2, 'Ultra Search uses a crawler to access documents.');
insert into collection values (3, 'XML is a tag-based markup language.');
insert into collection values (4, 'Oracle Database 11g XML DB treats XML 
as a native datatype in the database.');
insert into collection values (5, 'There are three Text index types to cover 
all text search needs.');
insert into collection values (6, 'Ultra Search also provides API 
for content management solutions.');

create index collectionx on collection(text) 
   indextype is ctxsys.context parameters('nopopulate');

/* prepare result tables, if you omit this step, procedure will create table automatically */
create table restab (       
       docid NUMBER,
       clusterid NUMBER,
       score NUMBER);

create table clusters (
       clusterid NUMBER,
       descript varchar2(4000),
       label varchar2(200),
       sze   number,
       quality_score number,
       parent number);

/* set the preference */
exec ctx_ddl.drop_preference('my_cluster');
exec ctx_ddl.create_preference('my_cluster','KMEAN_CLUSTERING');
exec ctx_ddl.set_attribute('my_cluster','CLUSTER_NUM','3');

/* do the clustering */
exec ctx_output.start_log('my_log');
exec ctx_cls.clustering('collectionx','id','restab','clusters','my_cluster');
exec ctx_output.end_log;

See Also:

Oracle Text Reference for CTX_CLS.CLUSTERING syntax and examples

PKGCyoPK&AOEBPS/cover.htmO Cover

Oracle Corporation

PK[pTOPK&AOEBPS/overview.htmK[ Understanding Oracle Text Application Development

1 Understanding Oracle Text Application Development

This chapter discusses the following topics:

1.1 Introduction to Oracle Text

Oracle Text enables you to build text query applications and document classification applications. Oracle Text provides indexing, word and theme searching, and viewing capabilities for text.

To design an Oracle Text application, first determine the type of queries you expect to run. This enables you to choose the most suitable index for the task.

Consider the following three categories of applications for Oracle Text:

1.2 Document Collection Applications

A text query application enables users to search document collections, such as Web sites, digital libraries, or document warehouses. The collection is typically static with no significant change in content after the initial indexing run. Documents can be of any size and of different formats, such as HTML, PDF, or Microsoft Word. These documents are stored in a document table. Searching is enabled by first indexing the document collection.

Queries usually consist of words or phrases. Application users can specify logical combinations of words and phrases using operators such as OR and AND. Other query operations can be used to improve the search results, such as stemming, proximity searching, and wildcarding.

An important factor for this type of application is retrieving documents relevant to a query while retrieving as few non-relevant documents as possible. The most relevant documents must be ranked high in the result list.

The queries for this type of application are best served with a CONTEXT index on your document table. To query this index, the application uses the SQL CONTAINS operator in the WHERE clause of a SELECT statement.

Figure 1-1 Overview of Text Query Application

Description of Figure 1-1 follows
Description of "Figure 1-1 Overview of Text Query Application"

1.2.1 Flowchart of Text Query Application

A typical text query application on a document collection enables the user to enter a query. The application enters a CONTAINS query and returns a list, called a hitlist, of documents that satisfy the query. The results are usually ranked by relevance. The application enables the user to view one or more documents in the hitlist.

For example, an application might index URLs (HTML files) on the World Wide Web and provide query capabilities across the set of indexed URLs. Hitlists returned by the query application are composed of URLs that the user can visit.

Figure 1-2 illustrates the flowchart of how a user interacts with a simple query application:

  1. The user enters a query.

  2. The application runs a CONTAINS query.

  3. The application presents a hitlist.

  4. The user selects document from hitlist.

  5. The application presents a document to the user for viewing.

Figure 1-2 Flowchart of a query application

Description of Figure 1-2 follows
Description of "Figure 1-2 Flowchart of a query application"

1.3 Catalog Information Applications

Catalog information consists of inventory type information, such as that of an online book store or auction site. The stored information consists of text information, such as book titles, and related structured information, such as price. The information is usually updated regularly to keep the online catalog up to date with the inventory.

Queries are usually a combination of a text component and a structured component. Results are almost always sorted by a structured component, such as date or price. Good response time is always an important factor with this type of query application.

Catalog applications are best served by a CTXCAT index. Query this index with the CATSEARCH operator in the WHERE clause of a SELECT statement.

Figure 1-3 illustrates the relation of the catalog table, its CTXCAT index, and the catalog application that uses the CATSEARCH operator to query the index.

Figure 1-3 A Catalog Query Application

Description of Figure 1-3 follows
Description of "Figure 1-3 A Catalog Query Application"

1.3.1 Flowchart for Catalog Query Application

A catalog application enables users to search for specific items in catalogs. For example, an online store application enables users to search for and purchase items in inventory. Typically, the user query consists of a text component that searches across the textual descriptions plus some other ordering criteria, such as price or date.

Figure 1-4 illustrates the flowchart of a catalog query application for an online electronics store.

  1. The user enters the query, consisting of a text component (for example, cd player) and a structured component (for example, order by price).

  2. The application executes the CATSEARCH query.

  3. The application shows the results ordered accordingly.

  4. The user browses the results.

  5. The user then either enters another query or performs an action, such as purchasing the item.

Figure 1-4 Flowchart of a Catalog Query Application

Description of Figure 1-4 follows
Description of "Figure 1-4 Flowchart of a Catalog Query Application"

1.4 Document Classification Applications

In a document classification application, an incoming stream or a set of documents is compared to a pre-defined set of rules. When a document matches one or more rules, the application performs some action.

For example, assume there is an incoming stream of news articles. You can define a rule to represent the category of Finance. The rule is essentially one or more queries that select document about the subject of Finance. The rule might have the form 'stocks or bonds or earnings'.

When a document arrives about a Wall Street earnings forecast and satisfies the rules for this category, the application takes an action, such as tagging the document as Finance or e-mailing one or more users.

To create a document classification application, create a table of rules and then create a CTXRULE index. To classify an incoming stream of text, use the MATCHES operator in the WHERE clause of a SELECT statement. See Figure 1-5 for the general flow of a classification application.

Figure 1-5 Overview of a Document Classification Application

Description of Figure 1-5 follows
Description of "Figure 1-5 Overview of a Document Classification Application"

1.5 XML Search Applications

An XML search application performs searches over XML documents. A regular document search usually searches across a set of documents to return documents that satisfy a text predicate; an XML search often uses the structure of the XML document to restrict the search. Typically, only that part of the document that satisfies the search is returned. For example, instead of finding all purchase orders that contain the word electric, the user might need only purchase orders in which the comment field contains electric.

Oracle Text enables you to perform XML searching using the following approaches:

1.5.1 Using Oracle Text

The CONTAINS operator is well suited to structured searching, enabling you to perform restrictive searches with the WITHIN, HASPATH, and INPATH operators. If you use a CONTEXT index, then you can also benefit from the following characteristics of Oracle Text searches:

  • Searches are token-based, whitespace-normalized

  • Hitlists are ranked by relevance

  • Case-sensitive searching

  • Section searching

  • Linguistic features such as stemming and fuzzy searching

  • Performance-optimized queries for large document sets


See Also:

"XML Section Searching with Oracle Text"

1.5.2 Using the Oracle XML DB Framework

With Oracle XML DB, you load your XML documents in an XMLType column. XML searching with Oracle XML DB usually consists of an XPATH expression within an existsNode(), extract(), or extractValue() query. This type of search can be characterized as follows:

  • It is a non-text search with equality and range on dates and numbers.

  • It is a string search that is character-based, where all characters are treated the same.

  • It has the ability to leverage the ora:contains() function with a CTXXPATH index to speed up existsNode() queries.

This type of search has the following disadvantages:

  • It has no special linguistic processing.

  • It uses exact matching, so there is no notion of relevance.

  • It can be very slow for some searches, such as wildcarding, as with:

    WHERE col1 like '%dog%'

See Also:

Oracle XML DB Developer's Guide

1.5.3 Combining Oracle Text features with Oracle XML DB

You can combine the features of Oracle Text and Oracle XML DB for applications where you want to do a full-text retrieval, leveraging the XML structure by entering queries such as "find all nodes that contain the word Pentium." Do so in one of two ways:


See Also:

Oracle XML DB Developer's Guide and "XML Section Searching with Oracle Text"

1.5.3.1 Using the Text-on-XML Method

With Oracle Text, you can create a CONTEXT index on a column that contains XML data. The column type can be XMLType, but it can also be any supported type provided you use the correct index preference for XML data.

With the Text-on-XML method, use the standard CONTAINS query and add a structured constraint to limit the scope of a search to a particular section, field, tag, or attribute. This amounts to specifying the structure inside text operators, such as WITHIN, HASPATH, and INPATH.

For example, set up your CONTEXT index to create sections with XML documents. Consider the following XML document that defines a purchase order.

<?xml version="1.0"?>
<PURCHASEORDER pono="1">
   <PNAME>Po_1</PNAME>
   <CUSTNAME>John</CUSTNAME>
   <SHIPADDR>
      <STREET>1033 Main Street</STREET>
      <CITY>Sunnyvalue</CITY>
      <STATE>CA</STATE>
   </SHIPADDR>
   <ITEMS>
     <ITEM>
       <ITEM_NAME> Dell Computer </ITEM_NAME>
       <DESC> Pentium 2.0 Ghz 500MB RAM  </DESC>
     </ITEM>
     <ITEM>
       <ITEM_NAME> Norelco R100 </ITEM_NAME>
       <DESC>Electric Razor </DESC>
     </ITEM>
   </ITEMS>
</PURCHASEORDER>

To query all purchase orders that contain Pentium within the item description section, use the WITHIN operator:

SELECT id from po_tab where CONTAINS( doc, 'Pentium WITHIN desc') > 0;

Specify more complex criteria with XPATH expressions using the INPATH operator:

SELECT id from po_tab where  CONTAINS(doc, 'Pentium INPATH (/purchaseOrder/items/item/desc') > 0;

1.5.3.2 Using the XML-on-Text Method

With the XML-on-Text method, you add text operations to an XML search. This includes using the ora:contains() function in the XPATH expression with existsNode(), extract(), and extractValue() queries. This amounts to including the full-text predicate inside the structure. For example:

SELECT
 Extract(doc, '/purchaseOrder//desc{ora:contains(.,"pentium")>0]',
                     'xmlns:ora=http://xmlns.oracle.com/xdb')
"Item Comment" FROM po_tab_xmltype
/

Additionally you can improve the performance of existsNode(), extract(), and extractValue() queries using the CTXXPATH Text domain index.

PKt(KKPK&AOEBPS/title.htm@ Oracle Text Application Developer's Guide, 11g Release 2 (11.2)

Oracle® Text

Application Developer's Guide

11g Release 2 (11.2)

E24435-01

August 2011

Oracle Text Application Developer's Guide, 11g Release 2 (11.2)

E24435-01

Copyright © 2004, 2011, Oracle and/or its affiliates. All rights reserved.

Primary Author: Cathy Shea, Paul Lane

Contributors:  Mohammad Faisal, Roger Ford, Wesley Lin, Yasuhiro Matsuda

This software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means. Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited.

The information contained herein is subject to change without notice and is not warranted to be error-free. If you find any errors, please report them to us in writing.

If this is software or related documentation that is delivered to the U.S. Government or anyone licensing it on behalf of the U.S. Government, the following notice is applicable:

U.S. GOVERNMENT RIGHTS Programs, software, databases, and related documentation and technical data delivered to U.S. Government customers are "commercial computer software" or "commercial technical data" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, the use, duplication, disclosure, modification, and adaptation shall be subject to the restrictions and license terms set forth in the applicable Government contract, and, to the extent applicable by the terms of the Government contract, the additional rights set forth in FAR 52.227-19, Commercial Computer Software License (December 2007). Oracle America, Inc., 500 Oracle Parkway, Redwood City, CA 94065.

This software or hardware is developed for general use in a variety of information management applications. It is not developed or intended for use in any inherently dangerous applications, including applications that may create a risk of personal injury. If you use this software or hardware in dangerous applications, then you shall be responsible to take all appropriate fail-safe, backup, redundancy, and other measures to ensure its safe use. Oracle Corporation and its affiliates disclaim any liability for any damages caused by use of this software or hardware in dangerous applications.

Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.

Intel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Opteron, the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark of The Open Group.

This software or hardware and documentation may provide access to or information on content, products, and services from third parties. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to third-party content, products, and services. Oracle Corporation and its affiliates will not be responsible for any loss, costs, or damages incurred due to your access to or use of third-party content, products, or services.

PKLE@PK&AOEBPS/query.htm Querying with Oracle Text

4 Querying with Oracle Text

This chapter describes Oracle Text querying and associated features. The following topics are covered:

4.1 Overview of Queries

The basic Oracle Text query takes a query expression, usually a word with or without operators, as input. Oracle Text returns all documents (previously indexed) that satisfy the expression along with a relevance score for each document. Scores can be used to order the documents in the result set.

To enter an Oracle Text query, use the SQL SELECT statement. Depending on the type of index you create, you use either the CONTAINS or CATSEARCH operator in the WHERE clause. You can use these operators programatically wherever you can use the SELECT statement, such as in PL/SQL cursors.

Use the MATCHES operator to classify documents with a CTXRULE index.

4.1.1 Querying with CONTAINS

When you create an index of type CONTEXT, you must use the CONTAINS operator to enter your query. An index of type CONTEXT is suited for indexing collections of large coherent documents.

With the CONTAINS operator, you can use a number of operators to define your search criteria. These operators enable you to enter logical, proximity, fuzzy, stemming, thesaurus and wildcard searches. With a correctly configured index, you can also enter section searches on documents that have internal structure such as HTML and XML.

With CONTAINS, you can also use the ABOUT operator to search on document themes.

4.1.1.1 CONTAINS SQL Example

In the SELECT statement, specify the query in the WHERE clause with the CONTAINS operator. Also specify the SCORE operator to return the score of each hit in the hitlist. The following example shows how to enter a query:

SELECT SCORE(1), title from news WHERE CONTAINS(text, 'oracle', 1) > 0;

You can order the results from the highest scoring documents to the lowest scoring documents using the ORDER BY clause as follows:

SELECT SCORE(1), title from news 
           WHERE CONTAINS(text, 'oracle', 1) > 0
           ORDER BY SCORE(1) DESC;

The CONTAINS operator must always be followed by the > 0 syntax, which specifies that the score value returned by the CONTAINS operator must be greater than zero for the row to be returned.

When the SCORE operator is called in the SELECT statement, the CONTAINS operator must reference the score label value in the third parameter as in the previous example.

4.1.1.2 CONTAINS PL/SQL Example

In a PL/SQL application, you can use a cursor to fetch the results of the query.

The following example enters a CONTAINS query against the NEWS table to find all articles that contain the word oracle. The titles and scores of the first ten hits are output.

declare 
  rowno number := 0; 
begin 
  for c1 in (SELECT SCORE(1) score, title FROM news 
              WHERE CONTAINS(text, 'oracle', 1) > 0
              ORDER BY SCORE(1) DESC) 
  loop 
    rowno := rowno + 1; 
    dbms_output.put_line(c1.title||': '||c1.score); 
    exit when rowno = 10; 
  end loop; 
end;

This example uses a cursor FOR loop to retrieve the first ten hits. An alias score is declared for the return value of the SCORE operator. The score and title are output to standard out using cursor dot notation.

4.1.1.3 Structured Query with CONTAINS

A structured query, also called a mixed query, is a query that has a CONTAINS predicate to query a text column and has another predicate to query a structured data column.

To enter a structured query, you specify the structured clause in the WHERE condition of the SELECT statement.

For example, the following SELECT statement returns all articles that contain the word oracle that were written on or after October 1, 1997:

SELECT SCORE(1), title, issue_date from news 
           WHERE CONTAINS(text, 'oracle', 1) > 0
           AND issue_date >= ('01-OCT-97') 
           ORDER BY SCORE(1) DESC;

Note:

Even though you can enter structured queries with CONTAINS, consider creating a CTXCAT index and issuing the query with CATSEARCH, which offers better structured query performance.

4.1.2 Querying with CATSEARCH

When you create an index of type CTXCAT, you must use the CATSEARCH operator to enter your query. An index of type CTXCAT is best suited when your application stores short text fragments in the text column and other associated information in related columns.

For example, an application serving an online auction site might have a table that stores item description in a text column and associated information such as date and price in other columns. With a CTXCAT index, you can create b-tree indexes on one or more of these columns. The result is that when you use the CATSEARCH operator to search a CTXCAT index, query performance is generally faster for mixed queries.

The operators available for CATSEARCH queries are limited to logical operations such as AND or OR. The operators you can use to define your structured criteria are greater than, less than, equality, BETWEEN, and IN.

4.1.2.1 CATSEARCH SQL Query

A typical query with CATSEARCH might include a structured clause as follows to find all rows that contain the word camera ordered by the bid_close date:

SELECT FROM auction WHERE CATSEARCH(title, 'camera', 'order by bid_close desc')> 0;

The type of structured query you can enter depends on how you create your sub-indexes.


See Also:

"Creating a CTXCAT Index"

As shown in the previous example, you specify the structured part of a CATSEARCH query with the third structured_query parameter. The columns you name in the structured expression must have a corresponding sub-index.

For example, assuming that category_id and bid_close have a sub-index in the ctxcat index for the AUCTION table, enter the following structured query:

SELECT FROM auction WHERE CATSEARCH(title, 'camera', 'category_id=99 order by bid_close desc')> 0;

4.1.2.2 CATSEARCH Example

The following example shows a field section search against a CTXCAT index using CONTEXT grammar by means of a query template in a CATSEARCH query.

-- Create and populate table
create table BOOKS (ID number, INFO varchar2(200), PUBDATE DATE);
 
insert into BOOKS values(1, '<author>NOAM CHOMSKY</author><subject>CIVIL
   RIGHTS</subject><language>ENGLISH</language><publisher>MIT
   PRESS</publisher>', '01-NOV-2003');
 
insert into BOOKS values(2, '<author>NICANOR PARRA</author><subject>POEMS 
  AND ANTIPOEMS</subject><language>SPANISH</language>
  <publisher>VASQUEZ</publisher>', '01-JAN-2001');
 
insert into BOOKS values(1, '<author>LUC SANTE</author><subject>XML
  DATABASE</subject><language>FRENCH</language><publisher>FREE
  PRESS</publisher>', '15-MAY-2002');
 
commit;
 
-- Create index set and section group
exec ctx_ddl.create_index_set('BOOK_INDEX_SET');
exec ctx_ddl.add_index('BOOKSET','PUBDATE');
 
exec ctx_ddl.create_section_group('BOOK_SECTION_GROUP',
      'BASIC_SECTION_GROUP');
exec ctx_ddl.add_field_section('BOOK_SECTION_GROUP','AUTHOR','AUTHOR');
exec ctx_ddl.add_field_section('BOOK_SECTION_GROUP','SUBJECT','SUBJECT');
exec ctx_ddl.add_field_section('BOOK_SECTION_GROUP','LANGUAGE','LANGUAGE');
exec ctx_ddl.add_field_section('BOOK_SECTION_GROUP','PUBLISHER','PUBLISHER'); 
 
-- Create index
create index books_index on books(info) indextype is ctxsys.ctxcat
  parameters('index set book_index_set section group book_section_group');
 
-- Use the index
-- Note that: even though CTXCAT index can be created with field sections, it
-- cannot be accessed using CTXCAT grammar (default for CATSEARCH).
-- We need to use query template with CONTEXT grammar to access field 
-- sections with CATSEARCH
 
select  id, info from books
where catsearch(info,
'<query>
      <textquery grammar="context">
              NOAM within author and english within language
      </textquery>
 </query>',
'order by pubdate')>0;

4.1.3 Querying with MATCHES

When you create an index of type CTXRULE, you must use the MATCHES operator to classify your documents. The CTXRULE index is essentially an index on the set of queries that define your classifications.

For example, if you have an incoming stream of documents that need to be routed according to content, you can create a set of queries that define your categories. You create the queries as rows in a text column. It is possible to create this type of table with the CTX_CLS.TRAIN procedure.

You then index the table to create a CTXRULE index. When documents arrive, you use the MATCHES operator to classify each document


See Also:

Chapter 6, "Classifying Documents in Oracle Text"

4.1.3.1 MATCHES SQL Query

A MATCHES query finds all rows in a query table that match a given document. Assuming that a table querytable has a CTXRULE index associated with it, enter the following query:

SELECT classification FROM querytable WHERE MATCHES(query_string,:doc_text) > 0;

Note the bind variable :doc_text which contains the document CLOB to be classified.

Combining everything into a simple example:

   create table queries (
      query_id      number,
      query_string  varchar2(80)
    );

    insert into queries values (1, 'oracle');
    insert into queries values (2, 'larry or ellison');
    insert into queries values (3, 'oracle and text');
    insert into queries values (4, 'market share');

    create index queryx on queries(query_string)
      indextype is ctxsys.ctxrule;

    select query_id from queries
     where matches(query_string, 
                   'Oracle announced that its market share in databases 
                    increased over the last year.')>0

This query will return queries 1 (the word oracle appears in the document) and 4 (the phrase market share appears in the document), but not 2 (neither the word larry nor the word ellison appears, and not 3 (there is no text in the document, so it does not match the query).

Note that, in this example, the document was passed in as a string for simplicity. Typically, your document would be passed in a bind variable.

The document text used in a matches query can be VARCHAR2 or CLOB. It does not accept BLOB input, so you cannot match filtered documents directly. Instead, you must filter the binary content to CLOB using the AUTO_FILTER filter. For the following example, we make two assumptions: one, that the document data is in the bind variable :doc_blob; and, two, that we have already defined a policy, my_policy, that CTX_DOC.POLICY_FILTER can use. For example:

  declare
    doc_text clob;
  begin
    -- create a temporary CLOB to hold the document text
    doc_text := dbms_lob.createtemporary(doc_text, TRUE, DBMS_LOB.SESSION);
 
    -- create a simple policy for this example
    ctx_ddl.create_preference(preference_name => 'fast_filter',
                        object_name       => 'AUTO_FILTER');
    ctx_ddl.set_attribute(preference_name => 'fast_filter',
                        attribute_name    => 'OUTPUT_FORMATTING',
                        attribute_value   => 'FALSE');
    ctx_ddl.create_policy(policy_name     => 'my_policy',
                        filter            => 'fast_filter);

    -- call ctx_doc.policy_filter to filter the BLOB to CLOB data
    ctx_doc.policy_filter('my_policy', :doc_blob, doc_text, FALSE);

    -- now do the matches query using the CLOB version
    for c1 in (select * from queries where matches(query_string, doc_text)>0)
    loop
      -- do what you need to do here
    end loop;

    dbms_lob.freetemporary(doc_text);
  end;

The procedure CTX_DOC.POLICY_FILTER filters the BLOB into the CLOB data, because you need to get the text into a CLOB to enter a MATCHES query. It takes as one argument the name of a policy you have already created with CTX_DDL.CREATE_POLICY. (See Oracle Text Reference for information on CTX_DOC.POLICY_FILTER.)

If your file is text in the database character set, then you can create a BFILE and load it to a CLOB using the function DBMS_LOB.LOADFROMFILE, or you can use UTL_FILE to read the file into a temp CLOB locator.

If your file needs AUTO_FILTER filtering, then you can load the file into a BLOB instead, and call CTX_DOC.POLICY_FILTER, as previously shown.


See Also:

Chapter 6, "Classifying Documents in Oracle Text" for more extended classification examples

4.1.3.2 MATCHES PL/SQL Example

The following example assumes that the table of queries profiles has a CTXRULE index associated with it. It also assumes that the table newsfeed contains a set of news articles to be categorized.

This example loops through the newsfeed table, categorizing each article using the MATCHES operator. The results are stored in the results table.

PROMPT  Populate the category table based on newsfeed articles
PROMPT
set serveroutput on;
declare
  mypk   number;
  mytitle varchar2(1000);
  myarticles clob;
  mycategory varchar2(100);
  cursor doccur is select pk,title,articles from newsfeed;
  cursor mycur is  select category from profiles where matches(rule, myarticles)>0;  
  cursor rescur is select category, pk, title from results order by category,pk;

begin
  dbms_output.enable(1000000);
  open doccur;
  loop
    fetch doccur into mypk, mytitle, myarticles;
    exit when doccur%notfound;
    open mycur;
    loop
      fetch mycur into mycategory;
      exit when mycur%notfound;
      insert into results values(mycategory, mypk, mytitle);
    end loop;
    close mycur;
    commit;
  end loop;
  close doccur;
  commit;

end;
/

The following example displays the categorized articles by category.

PROMPT  display the list of articles for every category
PROMPT
set serveroutput on;

declare
  mypk   number;
  mytitle varchar2(1000);
  mycategory varchar2(100);
  cursor catcur is select category from profiles order by category;
  cursor rescur is select pk, title from results where category=mycategory order by pk;

begin
  dbms_output.enable(1000000);
  open catcur;
  loop
    fetch catcur into mycategory;
    exit when catcur%notfound;
    dbms_output.put_line('********** CATEGORY: '||mycategory||' *************');
open rescur;
    loop
      fetch rescur into mypk, mytitle;
      exit when rescur%notfound;
dbms_output.put_line('**  ('||mypk||'). '||mytitle);
    end loop;
    close rescur;
    dbms_output.put_line('**');
dbms_output.put_line('*******************************************************');
  end loop;
  close catcur; 
end;
/

See Also:

Chapter 6, "Classifying Documents in Oracle Text" for more extended classification examples

4.1.4 Word and Phrase Queries

A word query is a query on a word or phrase. For example, to find all the rows in your text table that contain the word dog, enter a query specifying dog as your query term.

You can enter word queries with both CONTAINS and CATSEARCH SQL operators. However, phrase queries are interpreted differently.

4.1.4.1 CONTAINS Phrase Queries

If multiple words are contained in a query expression, separated only by blank spaces (no operators), the string of words is considered a phrase and Oracle Text searches for the entire string during a query.

For example, to find all documents that contain the phrase international law, enter your query with the phrase international law.

4.1.4.2 CATSEARCH Phrase Queries

With the CATSEARCH operator, the AND operator is inserted between words in phrases. For example, a query such as international law is interpreted as international AND law.

4.1.5 Querying Stopwords

Stopwords are words for which Oracle Text does not create an index entry. They are usually common words in your language that are unlikely to be searched on by themselves.

Oracle Text includes a default list of stopwords for your language. This list is called a stoplist. For example, in English, the words this and that are defined as stopwords in the default stoplist. You can modify the default stoplist or create new stoplists with the CTX_DDL package. You can also add stopwords after indexing with the ALTER INDEX statement.

You cannot query on a stopword by itself or on a phrase composed of only stopwords. For example, a query on the word this returns no hits when this is defined as a stopword.

You can query on phrases that contain stopwords as well as non-stopwords such as this boy talks to that girl. This is possible because the Oracle Text index records the position of stopwords even though it does not create an index entry for them.

When you include a stopword within your query phrase, the stopword matches any word. For example, the query:

'Jack was big'

matches phrases such as Jack is big and Jack grew big assuming was is a stopword. Note that this query matches grew, even though it is not a stopword.

4.1.6 ABOUT Queries and Themes

An ABOUT query is a query on a document theme. A document theme is a concept that is sufficiently developed in the text. For example, an ABOUT query on US politics might return documents containing information about US presidential elections and US foreign policy. Documents need not contain the exact phrase US politics to be returned.

During indexing, document themes are derived from the knowledge base, which is a hierarchical list of categories and concepts that represents a view of the world. Some examples of themes in the knowledge catalog are concrete concepts such as jazz music, football, or Nelson Mandela. Themes can also be abstract concepts such as happiness or honesty.

During indexing, the system can also identify and index document themes that are sufficiently developed in the document, but do not exist in the knowledge base.

You can augment the knowledge base to define concepts and terms specific to your industry or query application. When you do so, ABOUT queries are more precise for the added concepts.

ABOUT queries perform best when you create a theme component in your index. Theme components are created by default for English and French.


See Also:

Oracle Text Reference

4.1.6.1 Querying Stopthemes

Oracle Text enables you to query on themes with the ABOUT operator. A stoptheme is a theme that is not to be indexed. You can add and remove stopthemes with the CTX_DLL package. You can add stopthemes after indexing with the ALTER INDEX statement.

4.1.7 Query Expressions

A query expression is everything in between the single quotes in the text_query argument of the CONTAINS or CATSEARCH operator. What you can include in a query expression in a CONTAINS query is different from what you can include in a CATSEARCH operator.

4.1.7.1 CONTAINS Operators

A CONTAINS query expression can contain query operators that enable logical, proximity, thesaural, fuzzy, and wildcard searching. Querying with stored expressions is also possible. Within the query expression, you can use grouping characters to alter operator precedence. This book refers to these operators as the CONTEXT grammar.

With CONTAINS, you can also use the ABOUT query to query document themes.


See Also:

"The CONTEXT Grammar"

4.1.7.2 CATSEARCH Operator

With the CATSEARCH operator, you specify your query expression with the text_query argument and your optional structured criteria with the structured_query argument. The text_query argument enables you to query words and phrases. You can use logical operations, such as logical and, or, and not. This book refers to these operators as the CTXCAT grammar.

If you want to use the much richer set of operators supported by the CONTEXT grammar, you can use the query template feature with CATSEARCH.

With structured_query argument, you specify your structured criteria. You can use the following SQL operations:

  • =

  • <=

  • >=

  • >

  • <

  • IN

  • BETWEEN

You can also use ORDER BY clause to order your output.


See Also:

"The CTXCAT Grammar"

4.1.7.3 MATCHES Operator

Unlike CONTAINS and CATSEARCH, MATCHES does not take a query expression as input.

Instead, the MATCHES operator takes a document as input and finds all rows in a query (rule) table that match it. As such, you can use MATCHES to classify documents according to the rules they match.


See Also:

"Querying with MATCHES"

4.1.8 Case-Sensitive Searching

Oracle Text supports case-sensitivity for word and ABOUT queries.

4.1.8.1 Word Queries

Word queries are case-insensitive by default. This means that a query on the term dog returns the rows in your text table that contain the word dog, Dog, or DOG.

You can enable case-sensitive searching by enabling the mixed_case attribute in your BASIC_LEXER index preference. With a case-sensitive index, your queries must be entered in exact case. This means that a query on Dog matches only documents with Dog. Documents with dog or DOG are not returned as hits.

4.1.8.1.1 Stopwords and Case-Sensitivity

If you have case-sensitivity enabled for word queries and you enter a query on a phrase containing stopwords and non-stopwords, then you must specify the correct case for the stopwords. For example, a query on the dog does not return text that contains The Dog, assuming that the is a stopword.

4.1.8.2 ABOUT Queries

ABOUT queries give the best results when your query is formulated with proper case. This is because the normalization of your query is based on the knowledge catalog which is case-sensitive. Attention to case is required especially for words that have different meanings depending on case, such as turkey the bird and Turkey the country.

However, you need not enter your query in exact case to obtain relevant results from an ABOUT query. The system does its best to interpret your query. For example, if you enter a query of ORACLE and the system does not find this concept in the knowledge catalog, the system might use Oracle as a related concept for look-up.

4.1.9 Query Feedback

Feedback information provides broader term, narrower term, and related term information for a specified query with a context index. You obtain this information programatically with the CTX_QUERY.HFEEDBACK procedure.

Broader term, narrower term, and related term information is useful for suggesting other query terms to the user in your query application.

The feedback information returned is obtained from the knowledge base and contains only those terms that are also in the index. This increases the chances that terms returned from HFEEDBACK produce hits over the currently indexed document set.


See Also:

Oracle Text Reference for more information about using CTX_QUERY.HFEEDBACK

4.1.10 Query Explain Plan

Explain plan information provides a graphical representation of the parse tree for a CONTAINS query expression. You can obtain this information programatically with the CTX_QUERY.EXPLAIN procedure.

Explain plan information tells you how a query is expanded and parsed without having the system execute the query. Obtaining explain information is useful for knowing the expansion for a particular stem, wildcard, thesaurus, fuzzy, soundex, or ABOUT query. Parse trees also show the following information:

  • Order of execution

  • ABOUT query normalization

  • Query expression optimization

  • Stop-word transformations

  • Breakdown of composite-word tokens for supported languages


    See Also:

    Oracle Text Reference for more information about using CTX_QUERY.EXPLAIN

4.1.11 Using a Thesaurus in Queries

Oracle Text enables you to define a thesaurus for your query application.

Defining a custom thesaurus enables you to process queries more intelligently. Because users of your application might not know which words represent a topic, you can define synonyms or narrower terms for likely query terms. You can use the thesaurus operators to expand your query to include thesaurus terms.


See Also:

Chapter 10, "Working With a Thesaurus in Oracle Text"

4.1.12 Document Section Searching

Section searching enables you to narrow text queries down to sections within documents.

Section searching can be implemented when your documents have internal structure, such as HTML and XML documents. For example, you can define a section for the <H1> tag that enables you to query within this section using the WITHIN operator.

You can set the system to automatically create sections from XML documents.

You can also define attribute sections to search attribute text in XML documents.


Note:

Section searching is supported for only word queries with a CONTEXT index.


See Also:

Chapter 8, "Searching Document Sections in Oracle Text"

4.1.13 Using Query Templates

Query templates are an alternative to the existing query languages. Rather than passing a query string to CONTAINS or CATSEARCH, you pass a structured document that contains the query string in a tagged element. Within this structured document, or query template, you can enable additional query features:

4.1.14 Query Rewrite

Query applications sometimes parse end user queries, interpreting a query string in one or more ways using different operator combinations. For example, if a user enters a query of kukui nut, your application might enter the queries {kukui nut} and {kukui or nut} to increase recall.

The query rewrite feature enables you to submit a single query that expands the original query into the rewritten versions. The results are returned with no duplication.

You specify your rewrite sequences with the query template feature. The rewritten versions of the query are executed efficiently with a single call to CONTAINS or CATSEARCH.

The following template defines a query rewrite sequence. The query of {kukui nut} is rewritten as follows:

{kukui} {nut}

{kukui} ; {nut}

{kukui} AND {nut}

{kukui} ACCUM {nut}

The query rewrite template for these transformations is as follows:

select id from docs where CONTAINS (text,
 '<query>
   <textquery lang="ENGLISH" grammar="CONTEXT"> kukui nut
     <progression>
       <seq><rewrite>transform((TOKENS, "{", "}", " "))</rewrite></seq>
       <seq><rewrite>transform((TOKENS, "{", "}", " ; "))</rewrite></seq>
       <seq><rewrite>transform((TOKENS, "{", "}", "AND"))</rewrite></seq>
       <seq><rewrite>transform((TOKENS, "{", "}", "ACCUM"))</rewrite></seq>
     </progression>
   </textquery>
  <score datatype="INTEGER" algorithm="COUNT"/>
</query>')>0;

4.1.15 Query Relaxation

Query relaxation enables your application to execute the most restrictive version of a query first, progressively relaxing the query until the required number of hits are obtained.

For example, your application might search first on black pen and then the query is relaxed to black NEAR pen to obtain more hits.

The following query template defines a query relaxation sequence. The query of black pen is entered in sequence as the following:

{black} {pen}

{black} NEAR {pen}

{black} AND {pen}

{black} ACCUM {pen}

The query relaxation template for these transformations is as follows:

select id from docs where CONTAINS (text,
 '<query>
   <textquery lang="ENGLISH" grammar="CONTEXT">
     <progression>
       <seq>{black} {pen}</seq>
       <seq>{black} NEAR {pen}</seq>
       <seq>{black} AND {pen}</seq>
       <seq>{black} ACCUM {pen}</seq>
     </progression>
   </textquery>
   <score datatype="INTEGER" algorithm="COUNT"/>
</query>')>0;

Query hits are returned in this sequence with no duplication as long as the application needs results.

Query relaxation is most effective when your application needs the top n hits to a query, which you can obtain with the DOMAIN_INDEX_SORT hint, or the FIRST_ROWS hint, which has been deprecated, or in a PL/SQL cursor.

Using query templating to relax a query as such is more efficient than re-executing a query.

4.1.16 Query Language

When you use the multi-lexer to index a column containing documents in different languages, you can specify which language lexer to use during querying. You do so using the lang parameter in the query template.

With the MULTI_LEXER in previous releases, you could only change the query language by altering the session language before executing the query.

select id from docs where CONTAINS (text,
'<query><textquery lang="french">bon soir</textquery></query>')>0;

4.1.17 Alternative and User-defined Scoring

You can use query templating to specify alternative scoring algorithms to use, other than the default, to customize how CONTAINS is scored, and to enable SDATA to be used as part of the scoring expressions. In this way, you can mathematically define the scoring expression using not only pre-defined scoring components, but also SDATA components.

With alternative user-defined scoring, you can:

  • Specify the scoring expressions of terms by defining arithmetic expressions that define how the query should be scored, using

    • predefined scoring algorithms: DISCRETE, OCCURRENCE, RELEVANCE, and COMPLETION;

    • arithmetic operations: plus, minus, multiply, divide;

    • arithmetic functions: ABS(n), finding the absolute value of n ; LOG(n), finding the base-10 logarithmic value of n;

    • Numeric literals.

  • Specify the scoring expressions at the term level.

  • Specify terms that should not be taken into account when calculating the score.

  • Specify how the score from child elements of OR and AND operators should be merged.

  • Use SDATA that stores numeric or DATETIME values to affect the final score of the document.

The following example specifies an alternative scoring algorithm:

select id from docs where CONTAINS (text,
'<query>        
 <textquery grammar="CONTEXT" lang="english"> mustang  </textquery>     
 <score datatype="float" algorithm="DEFAULT"/>     
</query>')>0

The following query templating example includes SDATA values as part of the final score:

select id from docs where CONTAINS (text,
'<query>
<textquery grammar="CONTEXT" lang="english"> mustang </textquery>
<score datatype="float" algorithm="DEFAULT" normalization_expr =”doc_score+SDATA(price)”/>
</query>')>0"

See Also:

"Using DEFINESCORE and DEFINEMERGE for User-defined Scoring"

4.1.18 Alternative Grammar

Query templating enables you to use the CONTEXT grammar with CATSEARCH queries and vice-versa.

select id from docs where CONTAINS (text,
'<query> 
  <textquery grammar="CTXCAT">San Diego</textquery>
  <score datatype="integer"/>
</query>')>0;

4.1.19 Query Analysis

Oracle Text enables you to create a log of queries and to analyze the queries it contains. For example, suppose you have an application that searches a database of large animals, and your analysis of its queries shows that users are continually searching for the word mouse; this analysis might induce you to rewrite your application so that a search for mouse redirects the user to a database of small animals instead of simply returning an unsuccessful search.

With query analysis, you can find out

  • Which queries were made

  • Which queries were successful

  • Which queries were unsuccessful

  • How many times each query was made

You can combine these factors in various ways, such as determining the 50 most frequent unsuccessful queries made by your application.

You start query logging with CTX_OUTPUT.START_QUERY_LOG. The query log will contain all queries made to all context indexes that the program is using until a CTX_OUTPUT.END_QUERY_LOG procedure is entered. Use CTX_REPORT.QUERY_LOG_SUMMARY to get a report of queries made.


See Also:

Oracle Text Reference for syntax and examples for these procedures

4.1.20 Other Query Features

In your query application, you can use other query features such as proximity searching. Table 4-1 lists some of these features.

Table 4-1 Other Oracle Text Query Features

FeatureDescriptionImplement With

Case Sensitive Searching

Enables you to search on words or phrases exactly as entered in the query. For example, a search on Roman returns documents that contain Roman and not roman.

BASIC_LEXER when you create the index

Base Letter Conversion

Queries words with or without diacritical marks such as tildes, accents, and umlauts. For example, with a Spanish base-letter index, a query of energía matches documents containing both energía and energia.

BASIC_LEXER when you create the index

Word Decompounding

(German and Dutch)

Enables searching on words that contain specified term as sub-composite.

BASIC_LEXER when you create the index

Alternate Spelling

(German, Dutch, and Swedish)

Searches on alternate spellings of words.

BASIC_LEXER when you create the index

Proximity Searching

Searches for words near one another.

NEAR operator when you enter the query

Stemming

Searches for words with same root as specified term.

$ operator at when you enter the query

Fuzzy Searching

Searches for words that have similar spelling to specified term.

FUZZY operator when you enter the query

Query Explain Plan

Generates query parse information.

CTX_QUERY.EXPLAIN PL/SQL procedure after you index

Hierarchical Query Feedback

Generates broader term, narrower term and related term information for a query.

CTX_QUERY.HFEEDBACK PL/SQL procedure after you index.

Browse index

Browses the words around a seed word in the index.

CTX_QUERY.BROWSE_WORDS PL/SQL after you index.

Count hits

Counts the number of hits in a query.

CTX_QUERY.COUNT_HITS PL/SQL procedure after you index.

Stored Query Expression

Stores the text of a query expression for later reuse in another query.

CTX_QUERY.STORE_SQE PL/SQL procedure after you index.

Thesaural Queries

Uses a thesaurus to expand queries.

Thesaurus operators such as SYN and BT as well as the ABOUT operator.

Use CTX_THES package to maintain thesaurus.


4.2 The CONTEXT Grammar

The CONTEXT grammar is the default grammar for CONTAINS. With this grammar, you can add complexity to your searches with operators. You use the query operators in your query expression. For example, the logical operator AND enables you to search for all documents that contain two different words. The ABOUT operator enables you to search on concepts.

You can also use the WITHIN operator for section searching, the NEAR operator for proximity searches, the stem, fuzzy, and thesaural operators for expanding a query expression.

With CONTAINS, you can also use the CTXCAT grammar with the query template feature.

The following sections describe some of the Oracle Text operators.


See Also:

Oracle Text Reference for complete information about using query operators

4.2.1 ABOUT Query

Use the ABOUT operator in English or French to query on a concept. The query string is usually a concept or theme that represents the idea to be searched on. Oracle Text returns the documents that contain the theme.

Word information and theme information are combined into a single index. To enter a theme query, your index must have a theme component which is created by default in English and French.

Enter a theme query using the ABOUT operator inside the query expression. For example, to retrieve all documents that are about politics, write your query as follows:

SELECT SCORE(1), title FROM news 
           WHERE CONTAINS(text, 'about(politics)', 1) > 0
           ORDER BY SCORE(1) DESC;

See Also:

Oracle Text Reference for more information about using the ABOUT operator

4.2.2 Logical Operators

Logical operators such as AND or OR allow you to limit your search criteria in a number of ways. Table 4-2 describes some of these operators.

Table 4-2 Logical Operators

OperatorSymbolDescriptionExample Expression

AND

&

Use the AND operator to search for documents that contain at least one occurrence of each of the query terms.

Score returned is the minimum of the operands.

 
'cats AND dogs'
'cats & dogs'

OR

|

Use the OR operator to search for documents that contain at least one occurrence of any of the query terms.

Score returned is the maximum of the operands.

 
'cats | dogs'
'cats OR dogs'

NOT

~

Use the NOT operator to search for documents that contain one query term and not another.

To obtain the documents that contain the term animals but not dogs, use the following expression:

'animals ~ dogs'

ACCUM

,

Use the ACCUM operator to search for documents that contain at least one occurrence of any of the query terms. The accumulate operator ranks documents according to the total term weight of a document.

The following query returns all documents that contain the terms dogs, cats and puppies giving the highest scores to the documents that contain all three terms:

'dogs, cats, puppies'

EQUIV

=

Use the EQUIV operator to specify an acceptable substitution for a word in a query.

The following example returns all documents that contain either the phrase alsatians are big dogs or German shepherds are big dogs:

'German shepherds=alsatians are big dogs'

4.2.3 Section Searching

Section searching is useful for when your document set is HTML or XML. For HTML, you can define sections using embedded tags and then use the WITHIN operator to search these sections.

For XML, you can have the system automatically create sections for you. You can query with the WITHIN operator or with the INPATH operator for path searching.


See Also:

Chapter 8, "Searching Document Sections in Oracle Text"

4.2.4 Proximity Queries with NEAR and NEAR_ACCUM Operators

You can search for terms that are near to one another in a document with the NEAR operator.

For example, to find all documents where dog is within 6 words of cat, enter the following query:

'near((dog, cat), 6)'

The NEAR_ACCUM operator combines the functionality of the NEAR operator with that of the ACCUM operator. Like NEAR, it returns terms that are within a given proximity of each other; however, if one term is not found, it ranks documents according to the frequency of the occurrence of the term that is found.

Oracle Text also supports "mild near" within "mild not." For example:

term1 mnot near((term1,term2))

This query matches all documents containing the term1, unless the term1 is contained in a minimal span defined by the semantics near((term1,term2)).


See Also:

Oracle Text Reference for more information about using the NEAR and NEAR_ACCUM operators

4.2.5 Fuzzy, Stem, Soundex, Wildcard and Thesaurus Expansion Operators

You can expand your queries into longer word lists with operators such as wildcard, fuzzy, stem, soundex, and thesaurus.


See Also:


4.2.6 Using CTXCAT Grammar

You can use the CTXCAT grammar in CONTAINS queries. To do so, use a query template specification in the text_query parameter of CONTAINS.

You might take advantage of the CTXCAT grammar when you need an alternative and simpler query grammar.


See Also:

Oracle Text Reference for more information about using these operators

4.2.7 Stored Query Expressions

You can use the procedure CTX_QUERY.STORE_SQE to store the definition of a query without storing any results. Referencing the query with the CONTAINS SQL operator references the definition of the query. In this way, stored query expressions make it easy for defining long or frequently used query expressions.

Stored query expressions are not attached to an index. When you call CTX_QUERY.STORE_SQE, you specify only the name of the stored query expression and the query expression.

The query definitions are stored in the Text data dictionary. Any user can reference a stored query expression.


See Also:

Oracle Text Reference to learn more about the syntax of CTX_QUERY.STORE_SQE

4.2.7.1 Defining a Stored Query Expression

You define and use a stored query expression as follows:

  1. Call CTX_QUERY.STORE_SQE to store the queries for the text column. With STORE_SQE, you specify a name for the stored query expression and a query expression.

  2. Call the stored query expression in a query expression using the SQE operator. Oracle Text returns the results of the stored query expression in the same way it returns the results of a regular query. The query is evaluated at the time the stored query expression is called.

    You can delete a stored query expression using REMOVE_SQE.

4.2.7.2 SQE Example

The following example creates a stored query expression called disaster that searches for documents containing the words tornado, hurricane, or earthquake:

begin
ctx_query.store_sqe('disaster', 'tornado | hurricane | earthquake');
end;

To execute this query in an expression, write your query as follows:

SELECT SCORE(1), title from news 
   WHERE CONTAINS(text, 'SQE(disaster)', 1) > 0
   ORDER BY SCORE(1);

See Also:

Oracle Text Reference to learn more about the syntax of CTX_QUERY.STORE_SQE

4.2.8 Calling PL/SQL Functions in CONTAINS

You can call user-defined functions directly in the CONTAINS clause as long as the function satisfies the requirements for being named in a SQL statement. The caller must also have EXECUTE privilege on the function.

For example, assuming the function french returns the French equivalent of an English word, you can search on the French word for cat by writing:

SELECT SCORE(1), title from news 
   WHERE CONTAINS(text, french('cat'), 1) > 0
   ORDER BY SCORE(1);

See Also:

Oracle Database SQL Language Reference for more information about creating user functions and calling user functions from SQL

4.2.9 Optimizing for Response Time

A CONTAINS query optimized for response time provides a fast solution for when you need the highest scoring documents from a hitlist.

The following example returns the first twenty hits to standard out. This example uses the FIRST_ROWS(n) hint and a cursor.

declare 
cursor c is  
  select /*+ FIRST_ROWS(20) */ title, score(1) score 
    from news where contains(txt_col, 'dog', 1) > 0 order by score(1) desc; 
begin 
  for c1 in c 
  loop 
    dbms_output.put_line(c1.score||':'||substr(c1.title,1,50)); 
    exit when c%rowcount = 21; 
  end loop; 
end; 
/

See Also:

"Optimizing Queries for Response Time"

4.2.9.1 Other Factors that Influence Query Response Time

Besides using query hints, there are other factors that can influence query response time such as:

4.2.10 Counting Hits

To count the number of hits returned from a query with only a CONTAINS predicate, you can use CTX_QUERY.COUNT_HITS in PL/SQL or COUNT(*) in a SQL SELECT statement.

If you want a rough hit count, you can use CTX_QUERY.COUNT_HITS in estimate mode (EXACT parameter set to FALSE). With respect to response time, this is the fastest count you can get.

To count the number of hits returned from a query that contains a structured predicate, use the COUNT(*) function in a SELECT statement.

4.2.10.1 SQL Count Hits Example

To find the number of documents that contain the word oracle, enter the query with the SQL COUNT function as follows:

SELECT count(*) FROM news WHERE CONTAINS(text, 'oracle', 1) > 0;

4.2.10.2 Counting Hits with a Structured Predicate

To find the number of documents returned by a query with a structured predicate, use COUNT(*) as follows:

SELECT COUNT(*) FROM news WHERE CONTAINS(text, 'oracle', 1) > 0 and author = 'jones';

4.2.10.3 PL/SQL Count Hits Example

To find the number of documents that contain the word oracle, use COUNT_HITS as follows:

declare count number;
begin
  count := ctx_query.count_hits(index_name => my_index, text_query => 'oracle', exact => TRUE);
 dbms_output.put_line('Number of docs with oracle:');
 dbms_output.put_line(count);
end;

See Also:

Oracle Text Reference to learn more about the syntax of CTX_QUERY.COUNT_HITS

4.2.11 Using DEFINESCORE and DEFINEMERGE for User-defined Scoring

The DEFINESCORE operator enables you to define how the score for a term or phrase is to be calculated. The DEFINEMERGE operator defines how to merge scores of child elements of AND and OR operators. You can also use the alternative scoring template with SDATA to affect the final scoring of the document.


See Also:


4.3 The CTXCAT Grammar

The CTXCAT grammar is the default grammar for CATSEARCH. This grammar supports logical operations such as AND and OR as well as phrase queries.

The CATSEARCH query operators have the following syntax:

Table 4-3 CATSEARCH Query Operator Syntax

OperationSyntaxDescription of Operation

Logical AND

a b c

Returns rows that contain a, b and c.

Logical OR

a | b | c

Returns rows that contain a, b, or c.

Logical NOT

a - b

Returns rows that contain a and not b.

hyphen with no space

a-b

Hyphen treated as a regular character.

For example, if the hyphen is defined as skipjoin, words such as web-site treated as the single query term website.

Likewise, if the hyphen is defined as a printjoin, words such as web-site treated as web site with the space in the CTXCAT query language.

" "

"a b c"

Returns rows that contain the phrase "a b c".

For example, entering "Sony CD Player" means return all rows that contain this sequence of words.

( )

(A B) | C

Parentheses group operations. This query is equivalent to the CONTAINS query (A &B) | C.


4.3.1 Using CONTEXT Grammar with CATSEARCH

In addition, you can use the CONTEXT grammar in CATSEARCH queries. To do so, use a query template specification in the text_query parameter.

You might use the CONTAINS grammar as such when you need to enter proximity, thesaurus, or ABOUT queries with a CTXCAT index.


See Also:

Oracle Text Reference for more information about using these operators

PKqXO^@^PK&AOEBPS/cthes.htm Working With a Thesaurus in Oracle Text

10 Working With a Thesaurus in Oracle Text

This chapter describes how to improve your query application with a thesaurus. The following topics are discussed in this chapter:

10.1 Overview of Oracle Text Thesaurus Features

Users of your query application looking for information on a given topic might not know which words have been used in documents that refer to that topic.

Oracle Text enables you to create case-sensitive or case-insensitive thesauruses that define synonym and hierarchical relationships between words and phrases. You can then retrieve documents that contain relevant text by expanding queries to include similar or related terms as defined in the thesaurus.

You can create a thesaurus and load it into the system.


Note:

Oracle Text thesaurus formats and functionality are compliant with both the ISO-2788 and ANSI Z39.19 (1993) standards.

10.1.1 Oracle Text Thesaurus Creation and Maintenance

Thesauruses and thesaurus entries can be created, modified, and deleted by all Oracle Text users with the CTXAPP role.

10.1.1.1 CTX_THES Package

To maintain and browse your thesaurus programatically, you can use the PL/SQL package, CTX_THES. With this package, you can browse terms and hierarchical relationships, add and delete terms, and add and remove thesaurus relations.

10.1.1.2 Thesaurus Operators

You can also use the thesaurus operators in the CONTAINS clause to expand query terms according to your loaded thesaurus. For example, you can use the SYN operator to expand a term such as dog to its synonyms as follows:

'syn(dog)'

10.1.1.3 ctxload Utility

The ctxload utility can be used for loading thesauruses from a plain-text file into the thesaurus tables, as well as dumping thesauruses from the tables into output (or dump) files.

The thesaurus dump files created by ctxload can be printed out or used as input for other applications. The dump files can also be used to load a thesaurus into the thesaurus tables. This can be useful for using an existing thesaurus as the basis for creating a new thesaurus.


Caution:

To ensure sound security practices, Oracle recommends that you enter the password for ctxload using the interactive mode, which prompts you for the user password. Oracle strongly recommends that you do not enter a password on the command line.


10.1.2 Using a Case-sensitive Thesaurus

In a case-sensitive thesaurus, terms (words and phrases) are stored exactly as entered. For example, if a term is entered in mixed-case (using either the CTX_THES package or a thesaurus load file), the thesaurus stores the entry in mixed-case.


Note:

To take full advantage of query expansions that result from a case-sensitive thesaurus, your index must also be case-sensitive.

When loading a thesaurus, you can specify that the thesaurus be loaded case-sensitive using the -thescase parameter.

When creating a thesaurus with CTX_THES.CREATE_THESAURUS, you can specify that the thesaurus created be case-sensitive.

In addition, when a case-sensitive thesaurus is specified in a query, the thesaurus lookup uses the query terms exactly as entered in the query. Therefore, queries that use case-sensitive thesauruses allow for a higher level of precision in the query expansion, which helps lookup when and only when you have a case-sensitive index.

For example, a case-sensitive thesaurus is created with different entries for the distinct meanings of the terms Turkey (the country) and turkey (the type of bird). Using the thesaurus, a query for Turkey expands to include only the entries associated with Turkey.

10.1.3 Using a Case-insensitive Thesaurus

In a case-insensitive thesaurus, terms are stored in all-uppercase, regardless of the case in which they were originally entered.

The ctxload program loads a thesaurus in case-insensitive mode by default.

When creating a thesaurus with CTX_THES.CREATE_THESAURUS, the thesaurus is created as case-insensitive by default.

In addition, when a case-insensitive thesaurus is specified in a query, the query terms are converted to all-uppercase for thesaurus lookup. As a result, Oracle Text is unable to distinguish between terms that have different meanings when they are in mixed-case.

For example, a case-insensitive thesaurus is created with different entries for the two distinct meanings of the term TURKEY (the country or the type of bird). Using the thesaurus, a query for either Turkey or turkey is converted to TURKEY for thesaurus lookup and then expanded to include all the entries associated with both meanings.


See Also:

The "ctxload Utility"

10.1.4 Default Thesaurus

If you do not specify a thesaurus by name in a query, by default, the thesaurus operators use a thesaurus named DEFAULT. However, Oracle Text does not provide a DEFAULT thesaurus.

As a result, if you want to use a default thesaurus for the thesaurus operators, you must create a thesaurus named DEFAULT. You can create the thesaurus through any of the thesaurus creation methods supported by Oracle Text:

10.1.5 Supplied Thesaurus

Although Oracle Text does not provide a default thesaurus, Oracle Text does supply a thesaurus, in the form of a file that you load with ctxload, that can be used to create a general-purpose, English-language thesaurus.

The thesaurus load file can be used to create a default thesaurus for Oracle Text, or it can be used as the basis for creating thesauruses tailored to a specific subject or range of subjects.


See Also:

Oracle Text Reference to learn more about using ctxload and the CTX_THES package, and "ctxload Utility" in this chapter

10.1.5.1 Supplied Thesaurus Structure and Content

The supplied thesaurus is similar to a traditional thesaurus, such as Roget's Thesaurus, in that it provides a list of synonymous and semantically related terms.

The supplied thesaurus provides additional value by organizing the terms into a hierarchy that defines real-world, practical relationships between narrower terms and their broader terms.

Additionally, cross-references are established between terms in different areas of the hierarchy.

10.1.5.2 Supplied Thesaurus Location

The exact name and location of the thesaurus load file is operating system dependent; however, the file is generally named dr0thsus (with an appropriate extension for text files) and is generally located in the following directory structure:

<Oracle_home_directory>
    <interMedia_Text_directory>
       sample
           thes

See Also:

Oracle Database installation documentation specific to your operating system for more information about the directory structure of Oracle Text

10.2 Defining Terms in a Thesaurus

You can create synonyms, related terms, and hierarchical relationships with a thesaurus. The following sections give examples.

10.2.1 Defining Synonyms

If you have a thesaurus of computer science terms, you might define a synonym for the term XML as extensible markup language. This enables queries on either of these terms to return the same documents.

XML

SYN Extensible Markup Language

You can thus use the SYN operator to expand XML into its synonyms:

'SYN(XML)'

is expanded to:

'XML, Extensible Markup Language'

10.2.2 Defining Hierarchical Relations

If your document set is made up of news articles, you can use a thesaurus to define a hierarchy of geographical terms. Consider the following hierarchy that describes a geographical hierarchy for the U.S state of California:

California
   NT Northern California
       NT San Francisco
       NT San Jose
   NT Central Valley
       NT Fresno
   NT Southern California
       NT Los Angeles

You can thus use the NT operator to expand a query on California as follows:

'NT(California)'

expands to:

'California, Northern California, San Francisco, San Jose, Central Valley,
  Fresno, Southern California, Los Angeles'

The resulting hitlist shows all documents related to the U.S. state of California regions and cities.

10.3 Using a Thesaurus in a Query Application

Defining a custom thesaurus enables you to process queries more intelligently. Because users of your application might not know which words represent a topic, you can define synonyms or narrower terms for likely query terms. You can use the thesaurus operators to expand your query into your thesaurus terms.

There are two ways to enhance your query application with a custom thesaurus so that you can process queries more intelligently:

Each approach has its advantages and disadvantages.

10.3.1 Loading a Custom Thesaurus and Issuing Thesaurus-based Queries

To build a custom thesaurus, follow these steps:

  1. Create your thesaurus. See "Defining Terms in a Thesaurus".

  2. Load thesaurus with ctxload. The following example imports a thesaurus named tech_doc from an import file named tech_thesaurus.txt:

    ctxload -thes -name tech_doc -file tech_thesaurus.txt 

  3. 

    At the prompt, enter username and password. To ensure security, do not enter a password at the command line.
    

  4. 

    Use THES operators to query. For example, you can find all documents that contain XML and its synonyms as defined in tech_doc:
    

    'SYN(XML, tech_doc)'






10.3.1.1 Advantage


The advantage of using this method is that you can modify the thesaurus after indexing.








10.3.1.2 Limitations


This method requires you to use thesaurus expansion operators in your query. Long queries can cause extra overhead in the thesaurus expansion and slow your query down.










10.3.2 Augmenting Knowledge Base with Custom Thesaurus


You can add your custom thesaurus to a branch in the existing knowledge base. The knowledge base is a hierarchical tree of concepts used for theme indexing, ABOUT queries, and deriving themes for document services.


When you augment the existing knowledge base with your new thesaurus, you query with the ABOUT operator which implicitly expands to synonyms and narrower terms. You do not query with the thesaurus operators.


To augment the existing knowledge base with your custom thesaurus, follow these steps:


  1. 

    Create your custom thesaurus, linking new terms to existing knowledge base terms. See "Defining Terms in a Thesaurus" and "Linking New Terms to Existing Terms".
    

  2. 

    Load thesaurus with ctxload. See "Loading a Thesaurus with ctxload".
    

  3. 

    Compile the loaded thesaurus with ctxkbtc compiler. Refer to "Compiling a Loaded Thesaurus".
    

  4. 

    Index your documents. By default the system creates a theme component to your index.
    

  5. 

    Use ABOUT operator to query. For example, to find all documents that are related to the term politics including any synonyms or narrower terms as defined in the knowledge base, enter the query:
    

    'about(politics)'






10.3.2.1 Advantage


Compiling your custom thesaurus with the existing knowledge base before indexing enables faster and simpler queries with the ABOUT operator. Document services can also take full advantage of the customized information for creating theme summaries and Gists.








10.3.2.2 Limitations


Use of the ABOUT operator requires a theme component in the index, which requires slightly more disk space. You must also define the thesaurus before indexing your documents. If you make any change to the thesaurus, you must recompile your thesaurus and re-index your documents.








10.3.2.3 Linking New Terms to Existing Terms


When adding terms to the knowledge base, Oracle recommends that new terms be linked to one of the categories in the knowledge base for best results in theme proving.









See Also:

Oracle Text Reference for more information about the supplied English knowledge base






If new terms are kept completely separate from existing categories, fewer themes from new terms will be proven. The result of this is poor precision and recall with ABOUT queries as well as poor quality of gists and theme highlighting.


You link new terms to existing terms by making an existing term the broader term for the new terms.





10.3.2.3.1 Example: Linking New Terms to Existing Terms


You purchase a medical thesaurus medthes containing a a hierarchy of medical terms. The four top terms in the thesaurus are the following:


  • 

    Anesthesia and Analgesia
    

  • 

    Anti-Allergic and Respiratory System Agents
    

  • 

    Anti-Inflammatory Agents, Antirheumatic Agents, and Inflammation Mediators
    

  • 

    Antineoplastic and Immunosuppressive Agents
    



To link these terms to the existing knowledge base, add the following entries to the medical thesaurus to map the new terms to the existing health and medicine branch:


health and medicine
 NT Anesthesia and Analgesia
 NT Anti-Allergic and Respiratory System Agents
 NT Anti-Inflamammatory Agents, Antirheumatic Agents, and Inflamation Mediators
 NT Antineoplastic and Immunosuppressive Agents









10.3.2.4 Loading a Thesaurus with ctxload


Assuming the medical thesaurus is in a file called med.thes, you load the thesaurus as medthes with ctxload as follows:


ctxload -thes -thescase y -name medthes -file med.thes -user ctxsys



When you enter the ctxload command line, you are prompted for the user password. For best security practices, never enter the password at the command line. Alternatively, you may omit the -user and let ctxload prompt you for username and password, respectively.








10.3.2.5 Compiling a Loaded Thesaurus


To link the loaded thesaurus medthes to the knowledge base, use ctxkbtc as follows:


ctxkbtc -user ctxsys -name medthes 



When you enter the ctxkbtc command line, you are prompted for the user password. As with ctxload, for best security practices, do not enter the password at the command line.









IMPORTANT:


In order to ensure sound security practices, Oracle recommends that you enter the password for ctxload and ctxkbtc using the interactive mode, which prompts you for the user password. Oracle strongly recommends that you do not enter a password on the command line.


















10.4 About the Supplied Knowledge Base


Oracle Text supplies a knowledge base for English and French. The supplied knowledge contains the information used to perform theme analysis. Theme analysis includes theme indexing, ABOUT queries, and theme extraction with the CTX_DOC package.


The knowledge base is a hierarchical tree of concepts and categories. It has six main branches:



The supplied knowledge base is like a thesaurus in that it is hierarchical and contains broader term, narrower term, and related term information. As such, you can improve the accuracy of theme analysis by augmenting the knowledge base with your industry-specific thesaurus by linking new terms to existing terms.









See Also:

"Augmenting Knowledge Base with Custom Thesaurus"











Note:

Oracle Text supplied knowledge bases may not necessarily be installed when Oracle Text is installed. You may need to separately install the knowledge bases if they have not been installed. For more information, refer to Oracle Database installation documentation specific to your operating system.





You can also extend theme functionality to other languages by compiling a language-specific thesaurus into a knowledge base.









See Also:

"Adding a Language-Specific Knowledge Base"







Knowledge Base Character Set


Knowledge bases can be in any single-byte character set. Supplied knowledge bases are in WE8ISO8859P1. You can store an extended knowledge base in another character set such as US7ASCII.





10.4.1 Adding a Language-Specific Knowledge Base


You can extend theme functionality to languages other than English or French by loading your own knowledge base for any single-byte whitespace delimited language, including Spanish.


Theme functionality includes theme indexing, ABOUT queries, theme highlighting, and the generation of themes, gists, and theme summaries with CTX_DOC.


You extend theme functionality by adding a user-defined knowledge base. For example, you can create a Spanish knowledge base from a Spanish thesaurus.


To load your language-specific knowledge base, follow these steps:


  1. 

    Load your custom thesaurus using ctxload. Refer to "Loading a Thesaurus with ctxload".
    

  2. 

    Set NLS_LANG so that the language portion is the target language. The charset portion must be a single-byte character set.
    

  3. 

    Compile the loaded thesaurus using ctxkbtc as follows:
    

    ctxkbtc -user ctxsys -name my_lang_thes
    

    Enter the password for -user when prompted. Refer to "Compiling a Loaded Thesaurus".
    

    This statement compiles your language-specific knowledge base from the loaded thesaurus.
    



To use this knowledge base for theme analysis during indexing and ABOUT queries, specify the NLS_LANG language as the THEME_LANGUAGE attribute value for the BASIC_LEXER preference.





10.4.1.1 Limitations


The following limitations apply for adding knowledge bases:


  • 

    Oracle supplies knowledge bases in English and French only. You must provide your own thesaurus for any other language.
    

  • 

    You can only add knowledge bases for languages with single-byte character sets. You cannot create a knowledge base for languages which can be expressed only in multibyte character sets. If the database is a multibyte universal character set, such as UTF-8, the NLS_LANG parameter must still be set to a compatible single-byte character set when compiling the thesaurus.
    

  • 

    Adding a knowledge base works best for whitespace delimited languages.
    

  • 

    You can have at most one knowledge base for each NLS_LANG language.
    

  • 

    Obtaining hierarchical query feedback information such as broader terms, narrower terms and related terms does not work in languages other than English and French. In other languages, the knowledge bases are derived entirely from your thesauruses. In such cases, Oracle recommends that you obtain hierarchical information directly from your thesauruses.
    


    

    

    See Also:
    
Oracle Text Reference for more information about theme indexing, ABOUT queries, using the CTX_DOC package, and the supplied English knowledge base
    

    













PK}{PK&AOEBPS/acase.htmHq

CONTEXT Query Application



A CONTEXT Query Application


This appendix describes how to build a simple Web search application using the CONTEXT index type, whether by writing your own code or by using the Oracle Text Wizard. The following topics are covered:






A.1 Web Query Application Overview


A common use of Oracle Text is to index HTML files on Web sites and provide search capabilities to users. The sample application in this appendix indexes a set of HTML files stored in the database and uses a Web server connected to Oracle Database to provide the search service.


This appendix describes two versions of the Web query application:



Both versions of these applications can be produced by means of a query application wizard, which produces the necessary code automatically.


You can view and download both the PSP and JSP application code, as well as the text query application wizard, at the Oracle Technology Network Web site:


http://www.oracle.com/technology/products/text



The text query application wizard Web page also contains complete instructions on how to use the wizard.


Figure A-1 shows what the JSP version of the text query application looks like. This application was created with the Oracle Text application wizard.




Figure A-1 The Text Query Application

Description of Figure A-1 follows

Description of "Figure A-1 The Text Query Application"





Figure A-2 shows the results of the text query.




Figure A-2 The Text Query Application with Results

Description of Figure A-2 follows

Description of "Figure A-2 The Text Query Application with Results"





The application returns links to documents containing the search term. Each document has four links:









A.2 The PSP Web Application


This application is based on PL/SQL server pages. Figure A-3, "The PSP Web Application" illustrates how the browser calls the PSP-stored procedure on Oracle Database through a Web server.




Figure A-3 The PSP Web Application

Description of Figure A-3 follows

Description of "Figure A-3 The PSP Web Application"








A.2.1 Web Application Prerequisites


This application has the following requirements:


  • 

    Your Oracle Database (version 8.1.6 or higher) is up and running.
    

  • 

    You have the Oracle PL/SQL gateway running.
    

  • 

    You have a Web server such as Apache up and running and correctly configured to send requests to Oracle Database.
    









A.2.2 Building the Web Application


This section describes how to build the PSP Web application.


Step 1   Create your Text Table


You must create a text table to store your HTML files. This example creates a table called search_table as follows:


create table search_table (tk numeric primary key, title varchar2(2000), 
  text clob);

Step 2   Load HTML Documents into Table Using SQL*Loader


You must load the text table with the HTML files. This example uses the control file loader.ctl to load the files named in loader.dat. The SQL*Loader statement is as follows:


% sqlldr userid=scott/tiger control=loader.ctl 

Step 3   Create the CONTEXT index


If you are using the text query wizard: The wizard produces a script to create an index. (See the instructions on the download Web page for the wizard.) Run that script.


If you are not using the wizard: Index the HTML files by creating a CONTEXT index on the text column as follows. Because you are indexing HTML, this example uses the NULL_FILTER preference type for no filtering and uses the HTML_SECTION_GROUP type:


create index idx_search_table on search_table(text)
  indextype is ctxsys.context parameters
  ('filter ctxsys.null_filter section group CTXSYS.HTML_SECTION_GROUP');

Step 4   Compile search_htmlservices Package in Oracle Database


The application must present selected documents to the user. To do so, Oracle Database must read the documents from the CLOB in search_table and output the result for viewing, This is done by calling procedures in the search_htmlservices package. The file search_htmlservices.sql must be compiled. You can do this at the SQL*Plus prompt:


SQL> @search_htmlservices.sql

Package created.

Step 5   Compile the search_html PSP page with loadpsp


The search page is invoked by calling search_html.psp from a browser. You compile search_html in Oracle Database with the loadpsp command-line program:


% loadpsp -replace -user scott/tiger search_html.psp
"search_html.psp": procedure "search_html" created.








See Also:

Oracle Database Advanced Application Developer's Guide for more information about using PSP




Step 6   Configure Your Web Server


You must configure your Web server to accept client PSP requests as a URL. Your Web server forwards these requests to Oracle Database and returns server output to the browser. See Figure A-3.


You can use the Oracle WebDB Web listener or Oracle Application Server, which includes the Apache Web server. See your Web server documentation for more information.


Step 7   Enter Query from Browser


You can access the query application from a browser using a URL. You configure the URL with your Web server. An example URL might look like:


http://server.example.com:7777/mypath/search_html



The application displays a query entry box in your browser and returns the query results as a list of HTML links, as shown in Figure A-1 and Figure A-2.










A.2.3 PSP Sample Code


This section lists the code used to build the example Web application. It includes the following files:






A.2.3.1 loader.ctl


This example shows a sample loader.ctl file. It is used by sqlldr to load the data file, loader.dat.


LOAD DATA 
        INFILE 'loader.dat'
        INTO TABLE search_table 
        REPLACE 
        FIELDS TERMINATED BY ';'
        (tk             INTEGER,
         title          CHAR,
         text_file      FILLER CHAR,
         text           LOBFILE(text_file) TERMINATED BY EOF)







A.2.3.2 loader.dat


This example shows a sample loader.dat file. Each row contains three fields: a reference number for the document, a label (or "title"), and the name of the HTML document to load into the text column of search_table. The file has been truncated for this example.


1;   Pizza Shredder;Pizza.html
2;   Refrigerator w/ Front-Door Auto Cantaloupe Dispenser;Cantaloupe.html
3;   Self-Tipping Couch;Couch.html
4;   Home Air Dirtier;Mess.html
5;   Set of Pet Magnets;Pet.html
6;   Esteem-Building Talking Pillow;Snooze.html
      . . .
28;   Shaggy Found Inspiration For Success In Jamaica ;shaggy_found.html
29;   Solar Flare Eruptions Likely ;solar_flare.html
30;   Supersonic Plane Breaks Food Barrier ;food_barrier.html
31;   SOUNDSCAN REPORT: Recipe for An Aspiring Top Ten;urban_groove_1.html
      . . .







A.2.3.3 search_htmlservices.sql


set define off
create or replace package search_htmlServices as
  procedure showHTMLDoc (p_id in numeric);
  procedure showDoc  (p_id in varchar2, p_query in varchar2);
end;
/
show errors;

create or replace package body search_htmlServices as

  procedure showHTMLDoc (p_id in numeric) is
    v_clob_selected   CLOB;
    v_read_amount     integer;
    v_read_offset     integer;
    v_buffer          varchar2(32767);
   begin


     select text into v_clob_selected from search_table where tk = p_id;
     v_read_amount := 32767;
     v_read_offset := 1;
   begin
    loop
      dbms_lob.read(v_clob_selected,v_read_amount,v_read_offset,v_buffer);
      htp.print(v_buffer);
      v_read_offset := v_read_offset + v_read_amount;
      v_read_amount := 32767;
    end loop;
   exception
   when no_data_found then
     null;
   end;
 end showHTMLDoc;


procedure showDoc (p_id in varchar2, p_query in varchar2) is

 v_clob_selected   CLOB;
 v_read_amount     integer;
 v_read_offset     integer;
 v_buffer          varchar2(32767);
 v_query           varchar(2000);
 v_cursor          integer;

 begin
   htp.p('<html><title>HTML version with highlighted terms</title>');
   htp.p('<body bgcolor="#ffffff">');
   htp.p('<b>HTML version with highlighted terms</b>');

   begin
     ctx_doc.markup (index_name => 'idx_search_table',
                     textkey    => p_id,
                     text_query => p_query,
                     restab     => v_clob_selected,
                     starttag   => '<i><font color=red>',
                     endtag     => '</font></i>');

     v_read_amount := 32767;
     v_read_offset := 1;
     begin
      loop
        dbms_lob.read(v_clob_selected,v_read_amount,v_read_offset,v_buffer);
        htp.print(v_buffer);
        v_read_offset := v_read_offset + v_read_amount;
        v_read_amount := 32767;
      end loop;
     exception
      when no_data_found then
         null;
     end;

     exception
      when others then
        null; --showHTMLdoc(p_id);
   end;
end showDoc;
end;
/
show errors


set define on







A.2.3.4 search_html.psp


<%@ plsql procedure="search_html" %>
<%@ plsql parameter="query" default="null" %>
<%! v_results numeric := 0; %>

<html>
<head>
  <title>search_html Search </title>
</head>
<body>

<%

If query is null Then
%>

  <center>
    <form method=post action="search_html">
     <b>Search for: </b>
     <input type=text name="query" size=30>&nbsp;
     <input type=submit value=Search>
  </center>
<hr>

<% 
  Else
%>

   <p>
   <%!
      color varchar2(6) := 'ffffff';
   %>

   <center>
     <form method=post action="search_html">
      <b>Search for:</b>
      <input type=text name="query" size=30 value="<%= query %>">
      <input type=submit value=Search>
     </form>
   </center>
   <hr>
   <p>

   <%
     -- select statement 
    for doc in (
                select /*+ DOMAIN_INDEX_SORT */ rowid, tk, title, score(1) scr
                from search_table
                where contains(text, query,1) >0
                order by score(1) desc
               ) 
         loop
           v_results := v_results + 1;
           if v_results = 1 then

   %>

             <center>
              <table border="0">
                <tr bgcolor="#6699CC">
                  <th>Score</th>
                  <th>Title</th>
                </tr>

  <%      end if; %>
          <tr bgcolor="#<%= color %>">
           <td> <%= doc.scr %>% </td>
           <td> <%= doc.title %>
           [<a href="search_htmlServices.showHTMLDoc?p_id=
                  <%= doc.tk %>">HTML</a>]
           [<a href="search_htmlServices.showDoc?p_id=
                  <%= doc.tk %>&p_query=<%= query %>">Highlight</a>]
           </td>
         </tr>

   <%
          if (color = 'ffffff') then
               color := 'eeeeee';
             else
               color := 'ffffff';
          end if;

     end loop; 
   %>

    </table>
   </center>

<% 
  end if;
%>
</body></html>











A.3 The JSP Web Application


Creating the JSP-based Web application involves most of the same steps as those used in building the PSP-based application (see "Building the Web Application"). You can use the same loader.dat and loader.ctl files. However, with the JSP-based application, you do not need to do the following:






A.3.1 Web Application Prerequisites


This application has the following requirements:


  • 

    Your Oracle database (version 8.1.6 or higher) is up and running.
    

  • 

    You have a Web server such as Apache up and running and correctly configured to send requests to Oracle Database.
    









A.3.2 JSP Sample Code


This section lists the Java code used to build the example Web application. It includes the following files:


  • 

    search_html.jsp
    

    The code for this file was generated by the text query application wizard. (Some longer lines have been split to make the code easier to read.)
    






A.3.2.1 search_html.jsp


<%@ page import="java.sql.*, java.util.*, java.net.*, 
   oracle.jdbc.*, oracle.jsp.dbutil.*" %>
<%@ page contentType="text/html;charset=UTF-8" %>
<% oracle.jsp.util.PublicUtil.setReqCharacterEncoding(request, "UTF-8"); %>
<jsp:useBean id="name" class="oracle.jsp.jml.JmlString" scope ="request" >
<jsp:setProperty name="name" property="value" param="query" />
</jsp:useBean>
 
<%
String connStr="jdbc:oracle:thin:@jsmith-pc.us.oracle.com:1521:zippy922";
 
java.util.Properties info=new java.util.Properties();
Connection conn = null;
ResultSet rset = null;
OracleCallableStatement callStmt = null;
Statement stmt = null;
String userQuery = null;
String myQuery = null;
URLEncoder myEncoder;
int count=0;
int loopNum=0;
int startNum=0;
if (name.isEmpty()) {
%>
  <html>
    <title>Text Search</title>
    <body>
      <table width="100%">
        <tr bgcolor="#336699">
          <td><font face="arial, helvetica" align="left" 
          color="#CCCC99" size=+2>Text Search</td>
        </tr>
      </table>
    <center>
      <form method = post>
      Search for:
      <input type=text name=query size = 30>
      <input type=submit value="Search">
      </form>
    </center>
    </body>
  </html>
 
<%}
 
else {
%>
  <html>
    <title>Text Search</title>
    <body text="#000000" bgcolor="#FFFFFF" link="#663300" 
          vlink="#996633" alink="#ff6600">
      <table width="100%">
        <tr bgcolor="#336699">
          <td><font face="arial, helvetica" align="left" 
                 color="#CCCC99" size=+2>Text Search</td>
        </tr>
      </table>
    <center>
      <form method = post action="TextSearchApp.jsp">
      Search for:
      <input type=text name="query" value="<%=name.getValue() %>" size = 30>
      <input type=submit value="Search">
      </form>
    </center>
<%
  try {
    DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver() );
    info.put ("user", "jsmith");
    info.put ("password","hello");
    conn = DriverManager.getConnection(connStr,info);
    stmt = conn.createStatement();
    userQuery =   request.getParameter("query");
    myQuery =   URLEncoder.encode(userQuery);
    String numStr =   request.getParameter("sn");
    if(numStr!=null)
      startNum=Integer.parseInt(numStr);
    String theQuery =   translate(userQuery);
    callStmt =(OracleCallableStatement)conn.prepareCall("begin "+
         "?:=ctx_query.count_hits(index_name=>'ULTRA_IDX1', "+
         "text_query=>?"+
         "); " +
         "end; ");
    callStmt.setString(2,theQuery);
    callStmt.registerOutParameter(1, OracleTypes.NUMBER);
    callStmt.execute();
    count=((OracleCallableStatement)callStmt).getNUMBER(1).intValue();
    if(count>=(startNum+20)){
%>
    <font color="#336699" FACE="Arial,Helvetica" SIZE=+1>Results
           <%=startNum+1%> - <%=startNum+20%> of <%=count%> matches
<%
    }
    else if(count>0){
%>
    <font color="#336699" FACE="Arial,Helvetica" SIZE=+1>Results
           <%=startNum+1%> - <%=count%> of <%=count%> matches
<%
    }
    else {
%>
    <font color="#336699" FACE="Arial,Helvetica" SIZE=+1>No match found
<%
    }
%>
  <table width="100%">
  <TR ALIGN="RIGHT">
<%
  if((startNum>0)&(count<=startNum+20))
  {
%>
    <TD ALIGN="RIGHT">
    <a href="TextSearchApp.jsp?sn=<%=startNum-20 %>&query=
            <%=myQuery %>">previous20</a>
    </TD>
<%
  }
  else if((count>startNum+20)&(startNum==0))
  {
%>
    <TD ALIGN="RIGHT">
    <a href="TextSearchApp.jsp?sn=<%=startNum+20 
          %>&query=<%=myQuery %>">next20</a>
    </TD>
<%
  }
  else if((count>startNum+20)&(startNum>0))
  {
%>
    <TD ALIGN="RIGHT">
    <a href="TextSearchApp.jsp?sn=<%=startNum-20 %>&query=
              <%=myQuery %>">previous20</a>
    <a href="TextSearchApp.jsp?sn=<%=startNum+20 %>&query=
              <%=myQuery %>">next20</a>
    </TD>
<%
  }
%>
  </TR>
  </table>
<%
    String ctxQuery = "select /*+ DOMAIN_INDEX_SORT */ rowid, 'TITLE',
     score(1) scr from 'ULTRA_TAB1' where contains('TEXT', '"+theQuery+"',1 )
     > 0 order by score(1) desc";
    rset = stmt.executeQuery(ctxQuery);
    String color = "ffffff";
    String rowid = null;
    String fakeRowid = null;
    String[] colToDisplay = new String[1];
    int myScore = 0;
    int items = 0;
    while (rset.next()&&items< 20) {
      if(loopNum>=startNum)
      {
        rowid = rset.getString(1);
        fakeRowid = URLEncoder.encode(rowid);
        colToDisplay[0] = rset.getString(2);
        myScore = (int)rset.getInt(3);
        items++;
        if (items == 1) {
%>
        <center>
          <table BORDER=1 CELLSPACING=0 CELLPADDING=0 width="100%"
            <tr bgcolor="#CCCC99">
              <th><font face="arial, helvetica" color="#336699">Score</th>
              <th><font face="arial, helvetica" color="#336699">TITLE</th>
              <th> <font face="arial, helvetica" 
                       color="#336699">Document Services</th>
            </tr>
<%   } %>
      <tr bgcolor="#FFFFE0">
        <td ALIGN="CENTER"> <%= myScore %>%</td>
        <td> <%= colToDisplay[0] %>
        <td>
        </td>
      </tr>
<%
      if (color.compareTo("ffffff") == 0)
        color = "eeeeee";
      else
        color = "ffffff";
      }
      loopNum++;
    }
} catch (SQLException e) {
%>
    <b>Error: </b> <%= e %><p>
<%
} finally {
  if (conn != null) conn.close();
  if (stmt != null) stmt.close();
  if (rset != null) rset.close();
  }
%>
  </table>
  </center>
  <table width="100%">
  <TR ALIGN="RIGHT">
<%
  if((startNum>0)&(count<=startNum+20))
  {
%>
    <TD ALIGN="RIGHT">
    <a href="TextSearchApp.jsp?sn=<%=startNum-20 %>&query=
               <%=myQuery %>">previous20</a>
    </TD>
<%
  }
  else if((count>startNum+20)&(startNum==0))
  {
%>
    <TD ALIGN="RIGHT">
    <a href="TextSearchApp.jsp?sn=<%=startNum+20 %>&query=
          <%=myQuery %>">next20</a>
    </TD>
<%
  }
  else if((count>startNum+20)&(startNum>0))
  {
%>
    <TD ALIGN="RIGHT">
    <a href="TextSearchApp.jsp?sn=<%=startNum-20 %>&query=
          <%=myQuery %>">previous20</a>
    <a href="TextSearchApp.jsp?sn=<%=startNum+20 %>&query=
          <%=myQuery %>">next20</a>
    </TD>
<%
  }
%>
  </TR>
  </table>
  </body></html>
<%}
 
%>
<%!
   public String translate (String input)
   {
      Vector reqWords = new Vector();
      StringTokenizer st = new StringTokenizer(input, " '", true);
      while (st.hasMoreTokens())
      {
        String token = st.nextToken();
        if (token.equals("'"))
        {
           String phrase = getQuotedPhrase(st);
           if (phrase != null)
           {
              reqWords.addElement(phrase);
           }
        }
        else if (!token.equals(" "))
        {
           reqWords.addElement(token);
        }
      }
      return getQueryString(reqWords);
   }
 
   private String getQuotedPhrase(StringTokenizer st)
   {
      StringBuffer phrase = new StringBuffer();
      String token = null;
      while (st.hasMoreTokens() && (!(token = st.nextToken()).equals("'")))
      {
        phrase.append(token);
      }
      return phrase.toString();
   }
 
 
   private String getQueryString(Vector reqWords)
   {
      StringBuffer query = new StringBuffer("");
      int length = (reqWords == null) ? 0 : reqWords.size();
      for (int ii=0; ii < length; ii++)
      {
         if (ii != 0)
         {
           query.append(" & ");
         }
         query.append("{");
         query.append(reqWords.elementAt(ii));
         query.append("}");
      }
      return query.toString();
   }
%>











PK'9VMqHqPK&AOEBPS/txtgloss.htm

Glossary



Glossary





alternate spelling


In Oracle Text, alternate spelling refers specifically to the use of spelling variations in German, Swedish, and Dutch; these variations may be indexed if the BASIC_LEXER attribute ALTERNATE_SPELLING has been specified.








attribute


An attribute is an optional parameter associated with a preference. For example, the BASIC_LEXER preference includes the base_letter attribute, which can have either the value of YES (perform base-letter conversions) or NO (do not perform such conversions). Attributes are set with the CTX_DDL.SET_ATTRIBUTE procedure or with the ALTER INDEX statement. See also: preference, base-letter conversion.








attribute section


A user-defined section, representing an attribute of an XML document, such as AUTHOR or TITLE. Attribute sections are added to section groups with CTX_DDL.ADD_ATTR_SECTION or with the ALTER INDEX statement. See also: AUTO_SECTION_GROUP, section, XML_SECTION_GROUP.








AUTO_SECTION_GROUP


A section group used to automatically crate a zone section for each start-and end-tag pair in an XML document; attribute sections are automatically created for XML tags that have attributes. See also: attribute section, section, section group, XML_SECTION_GROUP, zone section.








base-letter conversion


The conversion of a letter with alternate forms (such as accents, umlauts, or cedillas) to its basic form (for example, without an accent).








BASIC_SECTION_GROUP


A section group used to define sections where the start and end tags are of the form <tag> and </tag>. It does not support non-basic tags, such as comment tags or those with attributes or unbalanced parentheses. See also: HTML_SECTION_GROUP, section, section group.








case


Case refers to the capitalization of a word or letter, where upper-case letters are capitals (M instead of m, for example). Not all languages have case. Mixed-case indexing is supported for some languages, notably those of Western Europe.








classification


Also known as document classification. The conceptual separation of source documents into groups, or clusters, based on their content. For example, a group of documents might be separated into clusters concerning medicine, finance, and sports.


Oracle Text includes rule-based classification, in which a person writes the rules for classifying documents (in the form of queries), and Oracle Text performs the document classification according to the rules; supervised classification, in which Oracle Text creates classification rules based on a set of sample documents; and clustering (also known as unsupervised classification), in which the clusters and rules are both created by Oracle Text.








clustering


Also known as unsupervised classification. See: classification.








composite domain index


Also known as CDI type of index. An Oracle Text index that not only indexes and processes a specified text column, but also indexes and processes FILTER BY and ORDER BY structured columns that are specified during index creation. See also: domain index.








CONTEXT index


The basic type of Oracle Text index; an index on a text column. A CONTEXT index is useful when your source text consists of many large, coherent documents. Applications making use of CONTEXT indexes use the CONTAINS query operator to retrieve text.








CTXAPP role


A role for application developers that enables a user to create Oracle Text indexes and index preferences, and to use PL/SQL packages. This role should be granted to Oracle Text users.








CTXCAT index


A combined index on a text column and one or more other columns. Typically used to index small documents or text fragments, such as item names, prices and descriptions typically found in catalogs. The CTXCAT index typically has better mixed-query performance than the CONTEXT index.


Applications query this index with the CATSEARCH operator. This index is transactional, which means that it automatically updates itself with DML to the base table.








CTXRULE index


A CTXRULE index is used to build a document classification application. The CTXRULE index is an index created on a table of queries, where the queries serve as rules to define the classification criteria. This index is queried with the MATCHES operator.








CTXSYS user


The CTXSYS user is created at install time. The CTXSYS user can view all indexes; sync all indexes; run ctxkbtc, the knowledge base extension compiler; query all system-defined views; and perform all the tasks of a user with the CTXAPP role.








CTXXPATH index


An index used to speed up existsNode() queries on an XMLType column.








datastore


In Oracle Text, datastore refers to the method of storing text. The method is determined by specifying a storage preference of a particular type. For example, the DIRECT_DATASTORE type stores data directly into the text column, while the URL_DATASTORE specifies that data is stored externally in a location specified by a URL.








domain index


An Oracle Database domain index that indexes and processes a specified text column. See also: composite domain index.








endjoin


One or more non-alphanumeric characters that, when encountered as the last character in a token, explicitly identify the end of the token. The characters, as well as any startjoin characters that immediately follow it, are included in the Text index entry for the token. For example, if ++ is specified as an endjoin, then C++ will be recognized and indexed as a single token. See also: printjoin, skipjoin, startjoin.








field section


A field section is similar to a zone section, with the main difference that the content between the start and end tags of a field section can be indexed separately from the rest of the document. This enables field section content to be "hidden" from a normal query. (The INPATH and WITHIN operators may be used to find the term in such a section.) Field sections are useful when there is a single occurrence of a section in a document, such as a filed in a news header. Field sections are added to section groups with the CTX_DDL.ADD_FIELD_SECTION procedure or with the ALTER INDEX statement. See also: INPATH operator, section, WITHIN operator, zone section.








filtering


One of the steps in the Oracle Text index-creation process. Depending on the filtering preferences associated with the creation of the index, one of three things happens during filtering: Formatted documents are filtered into marked-up text; text is converted from a non-database character set to a database character set; or no filtering takes place (HTML, XML, and plain-text documents are not filtered).








fuzzy matching


A fuzzy-matching query is one in which the query is expanded to include words that are spelled similarly to the specified term. This type of expansion is helpful for finding more accurate results when there are frequent misspellings in a document set. Fuzzy matching is invoked with the FUZZY query operator.








HASPATH operator


A CONTAINS query operator used to find XML documents that contain a section path exactly as specified in the query. See also: PATH_SECTION_GROUP.








highlighting


Generically, in Oracle Text, highlighting refers to generating a version of a document, or document fragments, with query terms displayed or called out in a special way.


Specifically, there are three forms of highlighting. First, CTX_DOC.MARKUP returns a document with the query term surrounded by plaintext or HTML tags. Second, CTX_DOC.HIGHLIGHT returns offsets for the query terms, allowing the user to mark up the document as desired. Third, CTX_DOC.SNIPPET produces a concordance, with the query term displayed in fragments of surrounding text. markup.








HTML_SECTION_GROUP


A section group type used for defining sections in HTML documents. See also: BASIC_SECTION_GROUP, section, section group.








INPATH operator


A CONTAINS query operator used to search within tags, or paths, of an XML document. It enables more generic path denomination than the WITHIN operator. See also: WITHIN operator.








Key Word in Context (KWIC)


In Oracle Text, a presentation of a query term with the text that surrounds it in the source document. This presentation may consist of a single instance of the query term, several instances, or every instance in the source document. The CTX_DOC.SNIPPET procedure produces such a presentation. Also known as Key Word in Context (KWIC).








knowledge base


Oracle Text includes a knowledge base, which is a hierarchical tree of concepts used for theme indexing, ABOUT queries, and deriving themes for document services. The knowledge base may be optionally installed. You can create your own knowledge base or extend the standard Oracle Text knowledge base.








lexer


The Oracle Text lexer breaks source text into tokens—usually words—in accordance with a specified language. To extract tokens, the lexer uses parameters as defined by a lexer preference. These parameters include the definitions for the characters that separate tokens, such as whitespace, and whether to convert text to all uppercase or not. When theme indexing is enabled, the lexer analyses text to create theme tokens.


When an application needs to index a table containing documents in more than one language, it can utilize the MULTI_LEXER (the multilingual lexer) and create sub-lexers to handle each language. Each sub-lexer is added to the main multi-lexer with the CTX_DDl.ADD_SUB_LEXER procedure.








markup


A form of highlighting. The CTX_DOC.MARKUP and CTX_DOC.POLICY_MARKUP procedures take a query term and a document, and return the document with the query terms marked up; that is, surrounded either by plaintext characters or HTML tags. You can use predefined markup tags or specify your own. In comparison, CTX_DOC.HIGHLIGHT and CTX_DOC.POLICY_HIGHLIGHT return offsets for query terms, so you can add your own highlighting tags. See also: highlighting.








MDATA


See: metadata.








MDATA section


An MDATA section contains user-defined index metadata. Use of this metadata can speed up mixed CONTAINS queries. See also: metadata, mixed query, section.








metadata


Metadata is information about a document that is not part of a document's regular content. For example, if an HTML document contains <author>Mark Twain</author>, author is considered the metadata type and Mark Twain is considered the value for author.


Sections containing metadata, known as MDATA sections, can be added to a document with the CTX_DDL.ADD_MDATA_SECTION procedure. Taking advantage of metadata can speed up mixed queries. Such queries can be made with the MDATA operator. See also: mixed query, section.








mixed query


A query that searches for two different types of information; for example, text content and document type. For example, a search for Romeo and Juliet in <title> metadata is a mixed query.







name search


Name searching (also called name matching) provides a solution to match proper names that might differ in spelling due to orthographic variation. It also enables you to search for somewhat inaccurate data, such as might occur when a record's first name and surname are not properly segmented.








NEWS_SECTION_GROUP


A section group type used for defining sections in newsgroup-formatted documents as defined by RFC 1036. See also: section, section group.








normalized word


The form of a word after it has been transformed for indexing, according to transformational rules in effect. Depending on the rules in effect, the normalized form of a word may be the same as the form found in the source document. The normalized form of a word may also include both the original and transformed versions. For example, if New German Spelling has been specified, the word Potential is normalized to both Potenzial and Potential.








NULL_SECTION_GROUP


The default section group type when no sections are defined or when only SENTENCE or PARAGRAPH sections are defined. See also: section, section group, special section.








PATH_SECTION_GROUP


A section group type used for indexing XML documents. It is similar to the AUTO_SECTION_GROUP type, except that it enables the use of the HASPATH and INPATH operators. See also: AUTO_SECTION_GROUP, HASPATH operator, INPATH operator, section, section group.








preference


A preference is an optional parameter that affects the way Oracle Text creates an index. For example, a lexer preference specifies the lexer to use when processing documents, such as the JAPANESE_VGRAM_LEXER. There are preferences for storage, filtering, lexers, classifiers, wordlist, section types, and more. A preference may or may not have attributes associated with it. Preferences are set with the CTX_DDL.CREATE_PREFERENCE procedure. See also: attribute.








printjoin


One or more non-alphanumeric character that, when they appear anywhere in a word (beginning, middle, or end), are processed as alphanumeric and included with the token in an Oracle Text index. This includes printjoins that occur consecutively.


For example, if the hyphen (-) and underscore (_) characters are defined as printjoins, terms such as pseudo-intellectual and _file_ are stored in the Oracle Text index as pseudo-intellectual and _file_.


Printjoins differ from endjoins and startjoins in that position does not matter. For example, $35 will be indexed as one token if $ is defined as a startjoin or a printjoin, but as two tokens if it is an endjoin. See also: endjoin, printjoin, startjoin.







result set


A page of search results in applications can consist of many disparate elements — metadata of the first few documents, total hit counts, per-word hit counts, and so on. Generating these results in earlier versions of Oracle Text required several queries and calls. Each extra call takes time to reparse the query and look up index metadata. Additionally, some search operations, such as iterative query refinement or breakdown top ten, are difficult for SQL.


The result set interface enables you to produce the various kinds of data needed for a page of search results all at once, thus improving performance by sharing overhead. The result set interface can also return data views that are difficult to express in SQL, such as top N by category queries.








rule-based classification


See: classification.








SDATA section


Structured/Sort Data section. Unlike the MDATA section type, which only supports equality searches, SDATA sections are designed to also support range searches. By default, all FILTER BY and ORDER BY columns are mapped as SDATA sections. An SDATA section contains user-defined index metadata. Use of this type of section can speed up mixed CONTAINS queries. See also: mixed query, section.








section


A section is a subdivision of a document; for example, everything within an <a>...</a> section of an HTML page.


Dividing a document into sections and then searching within sections enables you to narrow text queries down to blocks of text within documents. Section searching is useful when your documents have internal structure, such as HTML and XML documents. You can also search for text at the sentence and paragraph level.


Section searching is performed with the HASPATH, ISPATH, or WITHIN operator. Sections searching is enabled by the used of the section group when indexing.


The various section types include attribute, field, HTML, MDATA, special, stop, XML, and zone sections.








section group


A section group identifies a type of document set and implicitly indicate the tag structure for indexing. For instance, to index HTML tagged documents, you use the HTML_SECTION_GROUP. section group type. Likewise, to index XML tagged documents, you can use the XML_SECTION_GROUP section group type. Section groups are declared with the CTX_DDL.CREATE_SECTION_GROUP procedure or with the ALTER INDEX statement. See also: section.








skipjoin


A non-alphanumeric character that, when it appears within a word, identifies the word as a single token; however, the character is not stored with the token in the Text index. For example, if the hyphen character '-' is defined as a skipjoin, the word pseudo-intellectual is stored in the Text index as pseudointellectual. See also: endjoin, printjoin, startjoin.








startjoin


One or more non-alphanumeric characters that, when encountered as the first character in a token explicitly identify the start of the token. The characters, as well as any other startjoins characters that immediately follow it, are included in the Text index entry for the token. For example, if '$' is defined as a startjoin, then $35 is indexed as a single token. In addition, the first startjoins character in a string of startjoins characters implicitly ends the previous token. See also: endjoin, printjoin, skipjoin.








stemming


The expansion of a query term to include all terms having the same root word. For example, stemming the verb talk yields talking, talks, and talked, as well as talk (but not talkie). Stemming is distinct from wildcard expansion, in which results are related only through spelling, not through morphology. See also: wildcard expansion.








special section


A document section that is not bounded by tags. Instead, sections are formed by plaintext document structures such as sentences and paragraphs. Special sections are added to a section group with the CTX_DDL.ADD_SPECIAL_SECTION procedure. See also: section, section group.








stop section


A section that, when added to an AUTO_SECTION_GROUP, causes the information for document sections of that type to be ignored during indexing; the section content may still be searched, however. Stop sections are added to section groups with the CTX_DDL.ADD_STOP_SECTION procedure. See also: AUTO_SECTION_GROUP, section, section group.








stopclass


A class of tokens, such as NUMBERs, that are to be skipped over during indexing. Stopclasses are specified by adding them to stoplists with CTX_DDL.ADD_STOPCLASS. See also: stoplist.








stoplist


A list of words, known as stopwords, themes (stopthemes), and data classes (stopclasses) that are not to be indexed. By default, the system indexes text using the system-supplied stoplist that corresponds to a given database language.


Oracle Text provides default stoplists for most common languages including English, French, German, Spanish, Chinese, Dutch, and Danish. These default stoplists contain only stopwords. Stoplists are created with CTX_DDL.CREATE_STOPLIST or with the ALTER INDEX statement. See also: stopclass, stoptheme, stopword.








stoptheme


A theme to be skip1ped over during indexing. Stopthemes are specified by adding them to stoplists with CTX_DDL.ADD_STOPTHEMES. See also: stoplist.








stopword


A word to be skipped over during indexing. Stopwords are specified by adding them to stoplists with CTX_DDL.ADD_STOPWORD. They can also be dynamically added to an index using the ALTER INDEX statement. See also: stoplist.








sub-lexer


See: lexer.








supervised classification


See: classification.








theme


A topic associated with a given document. A document may have many themes. A theme does not have to appear in a document; for example, a document containing the words San Francisco may have California as one of its themes.


Theme components are added to indexes with the INDEX_THEMES attribute of the BASIC_LEXER preference; they may be extracted from a document with CTX_DOC.THEMES and queried with the ABOUT operator.








unsupervised classification


Also known as clustering. See: classification.








wildcard expansion


The expansion of a query term to return words that fit a given pattern. For example, expansion of the query term %rot% would return both trot and rotten. Wildcard expansion is distinct from stemming. See also: stemming.








whitespace


Characters that are treated as blank spaces between tokens. The predefined default values for whitespace are 'space' and 'tab'. The BASIC_LEXER uses whitespace characters (in conjunction with punctuations and newline characters) to identify character strings that serve as sentence delimiters for sentence and paragraph searching.








WITHIN operator


A CONTAINS query operator used to search for query terms within a given XML document section. It is similar to the INPATH operator, but less generic. See also: INPATH operator.








wordlist


An Oracle Text preference that enables features such as fuzzy, stemming, and prefix indexing for better wildcard searching, as well as substring and prefix indexing. The wordlist preference improves performance for wildcard queries with CONTAINS and CATSEARCH. Create wordlists with the CTX_DDL.ADD_WORDLIST procedure or with the ALTER INDEX statement. See also: preference.








XML section


A section that defined by XML tags, enabling XML section searching. Indexing with XML sections permits automatic sectioning as well as declaring document-type-sensitive sections. XML section searching includes attribute searching as well as path section searching with the INPATH, HASPATH, and WITHIN operators. See also: section.








XML_SECTION_GROUP


A section group used for identifying XML documents for indexing. See also: section, section group.








zone section


The basic type of document section; a body of text delimited by start and end tags in a document. Zone sections are well suited for defining sections in HTML and XML documents. Zone sections are added to section groups with the CTX_DDL.ADD_ZONE_SECTION procedure or with the ALTER INDEX statement. See also: field section, section, section group.








PK+zAؖΖPK&AOEBPS/admin.html

Administering Oracle Text



12 Administering Oracle Text


This chapter describes Oracle Text administration. The following topics are covered:






12.1 Oracle Text Users and Roles


While any user can create an Oracle Text index and enter a CONTAINS query, Oracle Text provides the CTXSYS user for administration and the CTXAPP role for application developers.





12.1.1 CTXSYS User


The CTXSYS user is created during installation time. CTXSYS can do the following:


  • 

    View all indexes
    

  • 

    Sync all indexes
    

  • 

    Run ctxkbtc, the knowledge base extension compiler
    

  • 

    Query all system-defined views
    

  • 

    Perform all the tasks of a user with the CTXAPP role
    








Note:

In previous releases of Oracle Text, CTXSYS had SYSDBA privileges, and only CTXSYS could perform certain functions, such as modifying system-defined preferences or setting system parameters.










12.1.2 CTXAPP Role


The CTXAPP role is a system-defined role that enables users to do the following:


  • 

    Create and delete Oracle Text preferences
    

  • 

    Use the Oracle Text PL/SQL packages
    



Any user can create an Oracle Text index and enter a Text query. The CTXAPP role enables users to create preferences and use the PL/SQL packages.








12.1.3 Granting Roles and Privileges to Users


The system uses the standard SQL model for granting roles to users. To grant a Text role to a user, use the GRANT statement.


In addition, to allow application developers to call procedures in the Oracle Text PL/SQL packages, you must explicitly grant to each user EXECUTE privileges for the Oracle Text package.









See Also:

"Creating an Oracle Text User" in Chapter 2, "Getting Started with Oracle Text"














12.2 DML Queue


When there are inserts, updates, or deletes to documents in your base table, the DML queue stores the requests for documents waiting to be indexed. When you synchronize the index with CTX_DDL.SYNC_INDEX, requests are removed from this queue.


Pending DML requests can be queried with the CTX_PENDING and CTX_USER_PENDING views.


DML errors can be queried with the CTX_INDEX_ERRORS or CTX_USER_INDEX_ERRORS view.









See Also:

Oracle Text Reference for more information about these views












12.3 The CTX_OUTPUT Package


Use the CTX_OUTPUT PL/SQL package to log indexing and document service requests.









See Also:

Oracle Text Reference for more information about this package












12.4 The CTX_REPORT Package


Use the CTX_REPORT package to produce reports on indexes and queries. These reports can help you fine-tune or troubleshoot your applications.







See Also:

Oracle Text Reference for more information about this package





The CTX_REPORT package contains the following procedures:


CTX_REPORT.DESCRIBE_INDEX
CTX_REPORT.DESCRIBE_POLICY


These procedures create reports that describe an existing index or policy, including the settings of the index metadata, the indexing objects used, the settings of the attributes of the objects, and (for CTX_REPORT.DESCRIBE_INDEX) index partition information, if any. These procedures are especially useful for diagnosing index-related problems.


This is sample output from DESCRIBE_INDEX, run on a simple context index:


=================================================================
                        INDEX DESCRIPTION
=================================================================
index name:                      "DR_TEST"."TDRBPRX0"
index id:                        1160
index type:                      context
base table:                      "DR_TEST"."TDRBPR"
primary key column:              ID
text column:                     TEXT2
text column type:                VARCHAR2(80)
language column:
format column:
charset column:
=================================================================
                          INDEX OBJECTS
=================================================================
datastore:                       DIRECT_DATASTORE
filter:                          NULL_FILTER
section group:                   NULL_SECTION_GROUP
lexer:                           BASIC_LEXER
wordlist:                        BASIC_WORDLIST
   stemmer:                         ENGLISH
   fuzzy_match:                     GENERIC
stoplist:                        BASIC_STOPLIST
   stop_word:                       teststopword
storage:                         BASIC_STORAGE
   r_table_clause:                  lob (data) store as (cache)
   i_index_clause:                  compress 2

CTX_REPORT.CREATE_INDEX_SCRIPT
CTX_REPORT.CREATE_POLICY_SCRIPT


CREATE_INDEX_SCRIPT creates a SQL*Plus script that can create a duplicate of a given text index. Use this when you have an index but don't have the original script (if any) used to create that script and want to be able to re-create the index. For example, if you accidentally drop a script, CREATE_INDEX_SCRIPT can re-create it; likewise, CREATE_INDEX_SCRIPT can be useful if you have inherited indexes from another user but not the scripts that created them.


CREATE_POLICY_SCRIPT does the same thing as CREATE_INDEX_SCRIPT, except that it enables you to re-create a policy instead of an index.


This is sample output from CREATE_INDEX_SCRIPT, run on a simple context index (not a complete listing):


begin
  ctx_ddl.create_preference('"TDRBPRX0_DST"','DIRECT_DATASTORE');
end;
/
...
/
begin
  ctx_ddl.create_section_group('"TDRBPRX0_SGP"','NULL_SECTION_GROUP');
end;
/
...
begin
  ctx_ddl.create_preference('"TDRBPRX0_WDL"','BASIC_WORDLIST');
  ctx_ddl.set_attribute('"TDRBPRX0_WDL"','STEMMER','ENGLISH');
  ctx_ddl.set_attribute('"TDRBPRX0_WDL"','FUZZY_MATCH','GENERIC');
end;
/
begin
  ctx_ddl.create_stoplist('"TDRBPRX0_SPL"','BASIC_STOPLIST');
  ctx_ddl.add_stopword('"TDRBPRX0_SPL"','teststopword');
end;
/
...
/
begin
  ctx_output.start_log('TDRBPRX0_LOG');
end;
/
create index "DR_TEST"."TDRBPRX0"
  on "DR_TEST"."TDRBPR"
      ("TEXT2")
  indextype is ctxsys.context
  parameters('
    datastore       "TDRBPRX0_DST"
    filter          "TDRBPRX0_FIL"
    section group   "TDRBPRX0_SGP"
    lexer           "TDRBPRX0_LEX"
    wordlist        "TDRBPRX0_WDL"
    stoplist        "TDRBPRX0_SPL"
    storage         "TDRBPRX0_STO"
  ')
/

CTX_REPORT.INDEX_SIZE


This procedure creates a report showing the names of the internal index objects, along with their tablespaces, allocated sizes, and used sizes. It is useful for DBAs who may need to monitor the size of their indexes (for example, when disk space is at a premium).


Sample output from this procedure looks like this (partial listing):


=================================================================
                INDEX SIZE FOR DR_TEST.TDRBPRX10
=================================================================
TABLE:                          DR_TEST.DR$TDRBPRX10$I
TABLESPACE NAME:                DRSYS
BLOCKS ALLOCATED:                                            4
BLOCKS USED:                                                 1
BYTES ALLOCATED:                               8,192 (8.00 KB)
BYTES USED:                                    2,048 (2.00 KB)

INDEX (LOB):                    DR_TEST.SYS_IL0000023161C00006$$
TABLE NAME:                     DR_TEST.DR$TDRBPRX10$I
TABLESPACE NAME:                DRSYS
BLOCKS ALLOCATED:                                            5
BLOCKS USED:                                                 2
BYTES ALLOCATED:                             10,240 (10.00 KB)
BYTES USED:                                    4,096 (4.00 KB)

INDEX (NORMAL):                 DR_TEST.DR$TDRBPRX10$X
TABLE NAME:                     DR_TEST.DR$TDRBPRX10$I
TABLESPACE NAME:                DRSYS
BLOCKS ALLOCATED:                                            4
BLOCKS USED:                                                 2
BYTES ALLOCATED:                               8,192 (8.00 KB)
BYTES USED:                                    4,096 (4.00 KB)

CTX_REPORT.INDEX_STATS


INDEX_STATS produces a variety of calculated statistics about an index, such as how many documents are indexed, how many unique tokens the index contains, average size of its tokens, fragmentation information for the index, and so on. An example of a use of INDEX_STATS might be in optimizing stoplists.


See Oracle Text Reference for an example of the output of this procedure.


CTX_REPORT.QUERY_LOG_SUMMARY


This procedure creates a report of logged queries, which you can use to perform simple analyses. With query analysis, you can find out:


  • 

    which queries were made
    

  • 

    which queries were successful
    

  • 

    which queries were unsuccessful
    

  • 

    how many times each query was made
    



You can combine these factors in various ways, such as determining the 50 most frequent unsuccessful queries made by your application.


See Oracle Text Reference for an example of the output of this procedure.


CTX_REPORT.TOKEN_INFO


TOKEN_INFO is used mainly to diagnose query problems; for instance, to check that index data is not corrupted. As an example, you can use it to find out which documents are producing unexpected or bad tokens.


CTX_REPORT.TOKEN_TYPE


This is a lookup function, used mainly as input to other functions (CTX_DDL.OPTIMIZE_INDEX, CTX_REPORT.TOKEN_INFO, and so on).










12.5 Text Manager in Oracle Enterprise Manager


Oracle Enterprise Manager provides Text Manager for configuring, maintaining, and administering Oracle Text indexes. With Text Manager you can perform all of the basic configuration and administration tasks for Oracle Text indexes. You can monitor the overall health of Text indexes for a single Oracle database instance or for the Oracle Real Application Clusters environment. Text Manager provides summaries of critical information and enables you to drill down to the level of detail that you want, to resolve issues, and to understand any actions that may need to occur. You access Text Manager by clicking the Schema tab from the database home page in Oracle Enterprise Manager, and then selecting Text Indexes under the Text Manager group. On the Text Indexes page, select an index name and click View to see information and attributes for that index.


The Text Indexes page shows the jobs that are in progress, scheduled within the last seven days, or are experiencing problems. From this page you can go to the Job Scheduler to see a summary of all jobs for this database instance, and to manage selected jobs. The online help in Oracle Enterprise Manager provides details and procedures for using each Text Manager feature.









Note:

You cannot create an Oracle Text index with Text Manager. Use the CREATE INDEX statement to create an Oracle Text index as described in Chapter 3, " Indexing with Oracle Text" under Creating Oracle Text Indexes.









12.5.1 Using Text Manager


From the main Text Manager page, you can perform the following actions on the selected index from the Actions list:


  • 

    Synchronize
    

  • 

    Optimize
    

  • 

    Rebuild
    

  • 

    Resume Failed Operation
    

  • 

    Show Logs
    

  • 

    Show Errors
    



You can also schedule jobs for the specified index.


To access Text Manager:


  1. 

    Log on to the database with a user account that is authorized to access Database Control. For example, this could be SYS or SYSTEM, with the password that you specified during database installation.
    

    Database Control displays the Database Home page.
    

  2. 

    Select the Schema tab from the Database Home page.
    

  3. 

    Click Text Indexes located under Text Manager.
    

    The Text Indexes page appears with a list of Text indexes for this database instance.
    



When you select a Text index from the Text Indexes page, options become available for that index for you to edit or perform actions. For example, to configure attributes for searching, click Edit for the selected index. From the Edit Text Index page, you can set attributes, including: Wild Card Maximum Term, Fuzzy Score, and Number of Fuzzy Expansions. You can change index and partition names, as well as specify settings for URL_DATASTORE in addition to other options.








12.5.2 Viewing General Information for a Text Index


You can use the View Text Index page to see general information about a specific index: index type, parallel degree, synchronization mode, wild card limit, fuzzy score, fuzzy numeric result, datastore, and so forth. Information about any partitions on the index is also available.


To view general information for a Text index:


  • 

    From the Text Indexes page, click the name of the index in the list of Text indexes.
    

    The View Text Index page opens with the General tab selected.
    



From here you can select actions to perform maintenance tasks.








12.5.3 Checking Text Index Health


You use the Text Indexes page in Text Manager to see the list of Text indexes and general health of the Text indexes for the database instance to help you understand any critical actions that may need to be taken in order to make sure that the entire application is performing properly. Information is displayed such as the status of the indexes and jobs submitted by users during the last seven days. Key information about the Text indexes is also displayed in a tabular form.


Use the Text Indexes page to see:


  • 

    The number of Text indexes that contain invalid partitions, and which are, therefore, invalid. The number of partitions that are invalid, if any, for all Text indexes is also shown.
    

  • 

    The number of indexes that are in an in-progress state, and the number of partitions, if any, that are in an in-progress state.
    

  • 

    The number of indexes where all partitions are valid and no activity is in progress.
    

  • 

    Sum total of the Text indexes found for this database instance.
    



Additionally, use the Text Indexes page to see the index type for each Text index, the owner, the number of documents that are not synchronized, total number of documents, and percentage of fragmentation.


You select a Text index from the list and then options become available for that index for you to edit or perform actions.










12.6 Servers and Indexing


You index documents and enter queries with standard SQL. No server is needed for performing batch DML. You can synchronize the CONTEXT index with the CTX_DDL.SYNC_INDEX procedure, or from Text Manager in Oracle Enterprise Manager.









See Also:

Chapter 3, " Indexing with Oracle Text" for more information about indexing and index synchronization












12.7 Database Feature Usage Tracking in Oracle Enterprise Manager


Database Feature Usage statistics in Oracle Enterprise Manager provide an approximation of how often various database features are used. Tracking this information is potentially useful for application development as well as for auditing. You access Database Feature Usage by clicking the Server tab in Oracle Enterprise Manager, and then selecting Database Feature Usage under the Database Configuration group.


The following information is gathered for Oracle Text:






12.7.1 Package Usage Statistics


For package usage statistics, Database Feature Usage captures information about how often, if ever, and when the following packages have been used:


  • 

    CTX_ADM
    

  • 

    CTX_CLS
    

  • 

    CTX_DDL
    

  • 

    CTX_DOC
    

  • 

    CTX_OUTPUT
    

  • 

    CTX_QUERY
    

  • 

    CTX_REPORT
    

  • 

    CTX_THES
    

  • 

    CTX_ULEXER
    









12.7.2 Index Usage Statistics


For index usage statistics, Database Feature Usage captures the number of existing indexes in the database. The statistics are captured separately for each index type: CONTEXT, CTXCAT, and CTXRULE.








12.7.3 SQL Operator Usage Statistics


For SQL operator usage statistics, Database Feature Usage captures whether the user has ever used the CONTAINS, CATSEARCH, and MATCHES operators.









Note:

The feature usage tracking statistics might not be 100% accurate.














12.8 Oracle Text on Oracle Real Application Clusters


Oracle Text queries can be parallelized across Oracle RAC nodes for maximum throughput and performance for OLAP applications. You can manage Oracle Text indexes on Oracle RAC nodes with Text Manager in Oracle Enterprise Manager as described in the previous section "Text Manager in Oracle Enterprise Manager".









See Also:

"Parallelizing Queries Across Oracle RAC Nodes"












PKo㪵llPK&AOEBPS/preface.htmv

Preface



Preface


This Preface contains these topics:




Audience


Oracle Text Application Developer's Guide is intended for users who perform the following tasks:



To use this document, you need to have experience with the Oracle object relational database management system, SQL, SQL*Plus, and PL/SQL.



Documentation Accessibility


For information about Oracle's commitment to accessibility, visit the Oracle Accessibility Program website at http://www.oracle.com/us/corporate/accessibility/index.html.



Access to Oracle Support


Oracle customers have access to electronic support through My Oracle Support. For information, visit http://www.oracle.com/support/contact.html or visit http://www.oracle.com/accessibility/support.html if you are hearing impaired.



Related Documents


For more information about Oracle Text, see:



For more information about Oracle Database, see:



For more information about PL/SQL, see:




Conventions


The following text conventions are used in this document:




ConventionMeaning
boldfaceBoldface type indicates graphical user interface elements associated with an action, or terms defined in text or the glossary.
italicItalic type indicates book titles, emphasis, or placeholder variables for which you supply particular values.
monospaceMonospace type indicates commands within a paragraph, URLs, code in examples, text that appears on the screen, or text that you enter.








PK:3PK&AOEBPS/index.htm

Index



Index

A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Z 



A


ABOUT query, 4.2.1


adding for your language, 10.4.1
case-sensitivity, 4.1.8.2
definition, 4.1.6


accents


indexing characters with, 3.2.8.2


ACCUM operator, 4.2.2
ADD_STOPCLASS procedure, 3.3.4.3
ADD_STOPTHEME procedure, 3.3.4.3, 3.3.4.3
ADD_STOPWORD procedure, 3.3.4, 3.3.4.3
ADD_SUB_LEXER procedure


example, 3.3.2.5


administration tool, 12.5
ALTER INDEX statement


rebuilding index, 3.4.5
resuming failed index, 3.4.3


alternate spelling, 3.2.8.3
alternative grammar, 4.1.18
alternative grammar template, 4.1.18
alternative scoring, 4.1.17
alternative scoring template, 4.1.17
AND operator, 4.2.2
application


sample, A, B


applications, updating, 13
attribute


searching XML, 8.3.2


attribute sections, 8.1.2.7
AUTO_FILTER filter, 3.1.3.2, 3.2.2, 3.2.4, 7.8.4
AUTO_SECTION_GROUP object, 8.1.1.1
automatic sections, 8.3.1





B


background DML, 12.6
base-letter conversion, 3.2.8.2
BASIC_LEXER, 3.2.5
BASIC_SECTION_GROUP object, 8.1.1.1
BFILE column, 3.2.1.1


indexing, 3.3.5.2


BINARY format column value, 3.2.2.2
BLOB column, 3.2.1.1


indexing, 3.3.5.2


blocking operations


tuning queries with, 7.6


bypassing rows, 3.2.3





C


cantaloupe dispenser, A.1
case-sensitive


ABOUT query, 4.1.8.2
indexing, 3.2.7
queries, 4.1.8
thesaurus, 10.1.2


catalog application, 2.4


example, 2.4


CATSEARCH, 4.1.2


creating index for, 3.3.6.3
operators, 4.3
SQL example, 4.1.2.1


CATSEARCH queries, 2.4
CHAR column, 3.2.1.1
Character Large Object (CLOB), 2.3
character set


indexing, 3.2.4
indexing mixed, 3.2.4.2


character set column, 3.2.1.6
charset column, 3.2.4.2
CHARSET_FILTER, 3.1.3.2, 3.2.4
Chinese indexing, 3.2.8.5
CHINESE_VGRAM_LEXER, 3.2.8.5
classification


Decision Tree (supervised), 6.4.1
rule-based, 6.3
simple, see rule-based classification
supervised, 6.4
SVM (supervised), 6.4.2
unsupervised


classification application


example, 2.5


CLOB (Character Large Object) datatype, 2.3
CLOB column, 3.2.1.1


indexing, 3.3.5.2


clustering, see unsupervised classification
column types


supported for indexing, 3.2.1.1


composite words


indexing, 3.2.8.4


concordance, 5.1.3.3
CONTAINS


operators, 4.2
PL/SQL example, 4.1.1.2
query, 4.1.1
SQL example, 4.1.1.1
structured query, 4.1.1.3


CONTAINS query, 2.3
CONTEXT grammar, 4.2
CONTEXT index


about, 3.1.1
creating, 3.3.1, 3.3.5
HTML example, 2.3, 3.3.5.5, A.2.2


couch, self-tipping, A.1
counting hits, 4.2.10
CREATE_INDEX_SCRIPT, 12.4
CREATE_POLICY_SCRIPT, 12.4, 12.4
CREATE_STOPLIST procedure, 3.3.4, 3.3.4.3
CTX_CLS.TRAIN procedure, 6.4
CTX_DDL.SYNC_INDEX procedure, 2.3
CTX_DOC.POLICY_SNIPPET procedure, 5.1.3.3
CTX_DOC.SNIPPET procedure, 5.1.3.3
CTX_INDEX_ERRORS view, 3.4.1, 12.2
CTX_OUTPUT.END_QUERY_LOG, 4.1.19
CTX_OUTPUT.START_QUERY_LOG, 4.1.19
CTX_PENDING view, 12.2
CTX_QUERY.RESULT_SET procedure, 11.2
CTX_REPORT, 3.5.3.5
CTX_REPORT package, 12.4
CTX_REPORT_QUERY_LOG_SUMMARY, 4.1.19
CTX_REPORT_TOKEN_TYPE, 12.4
CTX_REPORT.CREATE_INDEX_SCRIPT, 12.4
CTX_REPORT.CREATE_POLICY_SCRIPT, 12.4, 12.4
CTX_REPORT.DESCRIBE_INDEX, 12.4
CTX_REPORT.DESCRIBE_POLICY, 12.4
CTX_REPORT.INDEX_SIZE, 12.4
CTX_REPORT.INDEX_STATS, 12.4
CTX_REPORT.QUERY_LOG_SUMMARY, 12.4
CTX_REPORT.TOKEN_INFO, 12.4
CTX_THES package


about, 10.1.1.1


CTX_USER_INDEX_ERRORS view, 3.4.1, 12.2
CTX_USER_PENDING view, 12.2
CTXAPP role, 2.2, 12.1
CTXCAT grammar, 4.3
CTXCAT index


about, 3.1.1
about performance, 7.7.17
automatic synchronization, 2.4
creating, 2.4
example, 3.3.6


ctxkbtc


example, 10.3.2.5


ctxload


load thesaurus example, 10.1.1.3, 10.3.1, 10.3.2.4


CTXRULE index, 6.3.2


about, 3.1.1
allowable queries, 6.3.2
creating, 2.5.1, 3.3.7
lexer types, 6.3.2
limitations, 6.3.2
parameters, 6.3.2


CTXSYS user, 12.1
CTXXPATH index, 1.5.3.2


about, 3.1.1







D


data storage


index default, 3.3.5.2
preference example, 3.3.2.1.4


datastore


about, 3.1.3.1, 3.3.1


DATE column, 3.3.5.2
Decision Tree supervised classification, 6.4.1
default thesaurus, 10.1.4
DEFAULT_INDEX_MEMORY, 7.8.2
defaults


index, 3.3.5.2


DEFINEMERGE operator, 4.2.11
DEFINESCORE operator, 4.2.11
DESCRIBE_INDEX, 12.4
DETAIL_DATASTORE, 3.2.1.2.1


about, 3.2.1.8


diacritical marks


characters with, 3.2.8.2


DIRECT_DATASTORE, 3.2.1.2.1


about, 3.2.1.8
example, 3.3.2.1.1


DML


view pending, 3.5.1


DML processing


background, 12.6


DML queue, 12.2
document


classification, 3.3.7, 6


document format


affect on index performance, 7.8.4
affect on performance, 7.7.5


document formats


filtering, 3.2.2
supported, 3.2.1.7


document invalidation, 3.5.3.3
document presentation


about, 5.3


document sections, 3.3.3
document services


about, 5.3


DOMAIN_INDEX_NO_SORT hint


better throughput example, 7.2.2


DOMAIN_INDEX_SORT hint


better response time example, 7.1.2.1


DROP INDEX statement, 3.4.2
DROP_STOPLIST procedure, 3.3.4.3
dropping an index, 3.4.2





E


EQUIV operator, 4.2.2
errors


DML, 12.2
viewing, 3.4.1


explain plan, 4.1.10





F


feedback


query, 4.1.9


field section


definition, 8.1.2.2
nested, 8.1.2.2.2
repeated, 8.1.2.2.3
visible and invisible, 8.1.2.2.1


file paths


storing, 3.2.1.3


FILE_DATASTORE, 3.1.3.1


about, 3.2.1.3, 3.2.1.8
example, 3.3.2.1.4


filter


about, 3.1.3.2, 3.3.1


filtering


custom, 3.2.2.3
index default, 3.3.5.2
to plain text and HTML, 5.3


filtering documents, 3.2.2
FIRST_ROWS hint, 4.2.9


better throughput example, 7.2.2


FIRST_ROWS(n) hint, 7.1.2
format column, 3.2.1.6, 3.2.2.2, 3.2.3
formats


filtering, 3.2.2
supported, 3.2.1.7


fragmentation of index, 3.5.3.2, 7.9.2


viewing, 3.5.3.5


full themes


obtaining, 5.2.1.2.2


functional lookup, 7.7.6
fuzzy matching, 3.2.9


default, 3.3.5.2


fuzzy operator, 4.2.5





G


garbage collection, 3.5.3.3
German


alternate spelling, 3.2.8.3
composite words, 3.2.8.4


gist


definition, 5.2
example, 5.2.2.1


GIST procedure, 5.2.2
grammar


alternative, 4.1.18
CTXCAT, 4.3


grammar CONTEXT, 4.2
granting roles, 2.2, 12.1.3





H


HASPATH operator, 8.3.4


examples, 8.3.4.8


HFEEDBACK procedure, 4.1.9
highlighting


about, 5.3
overview, 5.1


highlighting documents, 2.3
highlighting text, 5.1.1
highlighting themes, 5.1.2
hit count, 4.2.10
home air dirtier, A.1
HTML


filtering to, 5.3
indexing, 3.3.2.2, 8.1.1.1
indexing example, 2.3, A.2.2
searching META tags, 8.2.2
zone section example, 3.3.3.1, 8.2.1


HTML_SECTION_GROUP object, 3.3.3.1, 8.1.1.1, 8.2.1


with NULL_FILTER, 2.3, 3.3.2.2, A.2.2







I


IGNORE


format column value, 3.2.3


IGNORE format column value, 3.2.2.2
index


about, 3.1
creating, 3.3
dropping, 3.4.2
fragmentation, 3.5.3.2
getting report on, 12.4
incrementally creating, 3.3.5.3
maintenance, 3.4
online recreation, 3.4.4.1
optimizing, 3.5.3, 3.5.3.6
rebuilding, 3.4.5
statistics on, 12.4
structure, 3.1.2, 3.5.3.1
synchronizing, 3.5.2, 12.6
viewing information on, 12.4


index defaults


general, 3.3.5.2


index engine


about, 3.1.3.5


index errors


viewing, 3.4.1


index fragmentation, 7.9.2
index memory, 7.8.2
index synchronization, 2.3
index types


choosing, 3.1.1


INDEX_SIZE, 12.4
INDEX_STATS, 12.4
INDEX_STATS procedure, 3.5.3.5
indexed lookup, 7.7.6
indexing


and views, 3.1.7
bypassing rows, 3.2.3
considerations, 3.2
overview of process, 3.1.3
parallel, 3.1.6, 7.8.5
resuming failed, 3.4.3
special characters, 3.2.6


indexing performance


FAQs, 7.8
parallel, 7.8.6


indexing time, 7.8.1
INPATH operator, 8.3.4


examples, 8.3.4.2


INSO_FILTER (deprecated), 13.3.1
INSO_OUTPUT_FORMATTING attribute (deprecated), 13.3.1
INSO_TIMEOUT attribute (deprecated), 13.3.1
INSOFILTER directive (deprecated), 13.3.1





J


Japanese indexing, 3.2.8.5
JAPANESE_LEXER, 3.2.8.5
Jdeveloper


Text wizard, 2.3.1, A, B







K


knowledge base


about, 10.4
augmenting, 10.3.2
linking new terms, 10.3.2.3
supported character set, 10.4
user-defined, 10.4.1


Korean indexing, 3.2.8.5
KOREAN_MORPH_LEXER, 3.2.8.5





L


language


default setting for indexing, 3.3.5.2


language specific features, 3.2.8
languages


indexing, 3.2.5


language-specific knowledge base, 10.4.1
lexer


about, 3.1.3.4, 3.3.1
and CTXRULE, 6.3.2


list of themes


definition, 5.2
obtaining, 5.2.1


loading text


about, 3.2.1


LOB columns


improving query performance, 7.7.11
indexing, 3.3.5.2


local partitioned index, 7.7.14


improved response time, 7.1.3


location of text, 3.2.1
locking parameter for sync_index, 3.5.2.3
logical operators, 4.2.2





M


magnet, pet see pet magnet
maintaining the index, 3.4
marked-up document


obtaining, 5.1.3.1


MARKUP procedure, 2.3, 5.1.3.1
MATCHES


about, 4.1.3
PL/SQL example, 3.3.7.3, 4.1.3.2
SQL example, 4.1.3.1


MATCHES operator, 2.5.1, 6.3.1
materialized views, indexes on
MAX_INDEX_MEMORY, 7.8.2
maxtime parameter for sync_index, 3.5.2.2
MDATA operator, 8.1.2.4
MDATA section, 8.1.2.4
memory allocation


index synchronization, 7.9.3
indexing, 7.8.2
querying, 7.7.10


META tag


creating zone section for, 8.2.2.1


metadata


adding, 8.1.2.4
removing, 8.1.2.4
section, 8.1.2.4


migrating from previous releases, 13
mixed formats


filtering, 3.2.2.2


mixed query, 8.1.2.4, 8.1.2.6
MULTI_COLUMN_DATASTORE, 3.2.1.2.1


about, 3.2.1.8
example, 3.3.2.1.2


MULTI_LEXER, 3.2.5.2


example, 3.3.2.5


multi-language columns


indexing, 3.2.5.2


multi-language stoplist


about, 3.3.4.1


multiple CONTAINS


improving performance, 7.7.12


MVIEW see materialized views





N


name matching, 9.1
name search, 9.1
NCLOB column, 3.3.5.2
NEAR operator, 4.2.4
NEAR_ACCUM operator, 4.2.4
nested zone sections, 8.1.2.1.3
NESTED_DATASTORE, 3.2.1.2.1


about, 3.2.1.8


NEWS_SECTION_GROUP object, 8.1.1.1
NOPOPULATE keyword


and incremental rebuild,and replace parameter, 3.3.5.3


nopopulate with RECREATE_INDEX_ONLINE, 3.4.4.1
NOT operator, 4.2.2
NULL_FILTER, 3.1.3.2


example, 2.3, 3.3.2.2, A.2.2


NULL_SECTION_GROUP object, 8.1.1.1
NUMBER column, 3.3.5.2





O


offset information


highlight, 5.1.3.2


online


recreating a CONTEXT indextype, 3.4.4.1


operator


MDATA, 8.1.2.4
SDATA, 8.1.2.6


operators


CATSEARCH, 4.3
CONTAINS, 4.2
logical, 4.2.2
thesaurus, 10.1.1.2


optimizing index, 3.5.3


example, 3.5.3.6
single token, 3.5.3.4


optimizing queries, 4.2.9


FAQs, 7.7
response time, 7.1
throughput, 7.2
with blocking operations, 7.6


OR operator, 4.2.2
ora


contains, 1.5.2


Oracle Enterprise Manager, 12.5
Oracle Enterprise Manager and Oracle Text, 12.5
Oracle Text pages in OEM, 12.5
Oracle XML DB, 1.5
out of line LOB storage


improving performance, 7.7.11







P


parallel indexing, 3.1.6, 7.8.5


partitioned table, 7.8.6


parallel queries, 7.5, 7.7.15


across Real Application Clusters (RAC) nodes, 7.5


partitioned index, 7.7.14


improved response time, 7.1.3


path section searching, 8.3.4
PATH_SECTION_GROUP


example, 8.3.4.1


pending DML


viewing, 3.5.1


pending updates, 12.2
performance tuning


indexing, 7.8
querying, 7.7
updating index, 7.9


pet magnet, A.1


gist, 5.3.3
illustration, 5.3
themes, 5.3.2


phrase query, 4.1.4
pizza shredder, A.1
plain text


indexing with NULL_FILTER, 3.3.2.2


plain text filtering, 5.3
PL/SQL functions


calling in contains, 4.2.8


POPULATE_PENDING, 3.3.5.4
preferences


creating (examples), 3.3.2
creating with admin tool, 12.5
dropping, 3.4.6


previous releases, migrating from, 13
printjoins character, 3.2.6.1
PROCEDURE_FILTER, 3.2.2.3
PSP application, A.2, B.2





Q


query


ABOUT, 4.2.1
analysis, 4.1.19
blocking operations, 7.6
case-sensitive, 4.1.8
CATSEARCH, 4.1.2, 4.1.2.1
CONTAINS, 4.1.1
counting hits, 4.2.10
CTXRULE, 6.3.2
getting report on, 12.4
log, 4.1.19
MATCHES, 4.1.3
mixed, 8.1.2.4, 8.1.2.6
optimizing for throughput, 7.2
overview, 4.1
parallel, 7.5
speeding up with MDATA, 8.1.2.4
speeding up with SDATA, 8.1.2.6
viewing information on, 12.4
viewing log of, 12.4


query analysis, 4.1.19
query application


example, 2.3
sample, 1.2.1


query explain plan, 4.1.10
query expressions, 4.1.7
query features, 4.1.20
query feedback, 4.1.9
query language, 4.1.16
query log, 4.1.19, 12.4
query optimization, 4.2.9


FAQs, 7.7
response time, 7.1


Query Parallelized Across Oracle RAC Nodes, 7.5.2
query performance


FAQs, 7.7


query relaxation, 4.1.15
query relaxation template, 4.1.15
query rewrite, 4.1.14
query rewrite template, 4.1.14
query template, 4.2.6, 4.3.1


lang parameter and, 4.1.16


Query Templates, 4.1.13
QUERY_LOG_SUMMARY, 12.4
queue


DML, 12.2







R


Real Application Clusters (RAC) and parallel queries, 7.5
rebuilding an index, 3.4.5, 3.4.5
RECREATE_INDEX_ONLINE, 3.4.4.1


and DML, 3.4.4.1


recreating a local partitioned index online, 3.4.4.1
recreating an index, 3.4.4
recreating an index online, 3.4.4.1
relaxing queries, 4.1.15
REMOVE_SQE procedure, 4.2.7.1
REMOVE_STOPCLASS procedure, 3.3.4.3
REMOVE_STOPTHEME procedure, 3.3.4.3
REMOVE_STOPWORD procedure, 3.3.4, 3.3.4.3
response time


improving, 7.1
optimizing for, 4.2.9


result buffer size


increasing, 7.6


result set interface, 11
result sets, 11
resuming failed index, 3.4.3
rewriting queries, 4.1.14
roles


granting, 2.2, 12.1.3
system-defined, 12.1


rule-based classification, 6.3





S


sample application, A, B
scoring


alternative, 4.1.17


SDATA operator, 8.1.2.6
SDATA section, 8.1.2.6
searching


XML, 1.5


section


attribute, 8.1.2.7
field, 8.1.2.2
groups and types, 8.1.2
HTML example, 3.3.3
MDATA, 8.1.2.4
nested, 8.1.2.1.3
overlapping, 8.1.2.1.2
repeated zone, 8.1.2.1.1
SDATA, 8.1.2.6
special, 8.1.2.8
stop section, 8.1.2.3
types and groups, 8.1.2
zone, 8.1.2.1


section group


about, 3.3.1
and section types, 8.1.2
creating with admin tool, 12.5


section searching, 4.2.3


about, 4.1.12, 8.1
enabling, 8.1.1
HTML, 8.2.1


sectioner


about, 3.1.3.3


sectioning


automatic, 8.3.1
path, 8.3.4


self-tipping couch, A.1
SGA memory allocation, 7.8.2
simple classification, see rule-based classification
single themes


obtaining, 5.2.1.2.1


size of index, viewing, 12.4
skipjoins character, 3.2.6.2
SORT_AREA_SIZE, 7.6, 7.7.10, 7.8.2
special characters


indexing, 3.2.6


special sections, 8.1.2.8
spelling


alternate, 3.2.8.3
searching different, 9.1


SQE operator, 4.2.7
stem operator, 3.2.9, 4.2.5
stemming


default, 3.3.5.2
improving performance, 7.7.13


stop section, 8.1.2.3
stopclass, 3.3.4.2, 3.3.4.2
stoplist, 3.3.4


about, 3.3.1
creating with admin tool, 12.5
default, 3.3.5.2
multi-language, 3.2.12.2, 3.3.4.1
PL/SQL procedures, 3.3.4.3


stoptheme, 3.3.4.2, 3.3.4.2


about, 3.2.12
definition, 4.1.6.1


stopword, 3.3.4, 3.3.4.2


about, 3.2.12, 4.1.5
case-sensitive, 4.1.8.1.1


storage


about, 3.3.1


STORE_SQE procedure, 4.2.7, 4.2.7.1
stored query expression, defining, 4.2.7.1
stored query expressions, 4.2.7
storing text, 3.2.1


about, 3.2.1.2


structure of index, 3.5.3.1
structured data


adding, 8.1.2.6
removing, 8.1.2.6
section, 8.1.2.6


structured query


example, 3.3.6


supervised classification, 6.4


Decision Tree, 6.4.1


SVM supervised classification, 6.4.2


memory requirements, 6.4.2


swap and noswap with RECREATE_INDEX_ONLINE, 3.4.4.1
SYN operator, 10.2.1
sync_index locking parameter, 3.5.2.3
sync_index maxtime parameter, 3.5.2.2
SYNC_INDEX procedure, 2.3
synchronize index, 2.3
synchronizing index, 3.5.2, 12.6


improving performance, 7.9


synonyms


defining, 10.2.1







T


talking pillow, A.1
template queries, 4.2.6, 4.3.1
templates, 4.1.13


query rewrite, 4.1.14


text column


supported types, 3.2.1.1


TEXT format column value, 3.2.2.2
text highlighting, 5.1.1
text storage, 3.2.1
theme functionality


adding, 10.4.1


theme highlighting, 5.1.2
theme summary


definition, 5.2


themes


indexing, 3.2.8.1


THEMES procedure, 5.2.1
thesaural queries


about, 4.1.11


thesaurus


about, 10.1
adding to knowledge base, 10.3.2
case-sensitive, 10.1.2
DEFAULT, 10.1.4
default, 10.1.4
defining terms, 10.2
hierarchical relations, 10.2.2
loading custom, 10.3.1
operators, 10.1.1.2
supplied, 10.1.5
using in application, 10.3


thesaurus operator, 4.2.5
throughput


improving query, 7.2


tildes


indexing characters with, 3.2.8.2


TOKEN_INFO, 12.4
TOKEN_TYPE, 12.4
tracing, 7.4
TRAIN procedure, 6.4
tuning queries


for response time, 7.1
for throughput, 7.2
increasing result buffer size, 7.6







U


umlauts


indexing characters with, 3.2.8.2


unsupervised classification, 6.5
updating index performance


FAQs, 7.9


updating your applications, 13
URL_DATASTORE


about, 3.2.1.8
example, 3.3.2.1.3


URLs


storing, 3.2.1.4


user


creating Oracle Text, 2.2
system-defined, 12.1


USER_DATASTORE, 3.1.7


about, 3.2.1.8


USER_FILTER, 3.2.2.3





V


VARCHAR2 column, 3.2.1.1
viewing information on indexes and queries, 12.4
viewing size of index, 12.4
views


and indexing, 3.1.7
materialized







W


wildcard operator, 4.2.5


improving performance, 7.7.13


WITHIN operator, 3.3.3
wizard


Oracle Text addin, 2.3.1, A, B


word query, 4.1.4


case-sensitivity, 4.1.8.1


wordlist


about, 3.3.1







X


XML DB, 1.5
XML documents


attribute searching, 8.3.2
doctype sensitive sections, 8.3.3
indexing, 8.1.1.1
section searching, 8.3


XML searching, 1.5
XML_SECTION_GROUP object, 8.1.1.1





Z


zone section


definition, 8.1.2.1
nested, 8.1.2.1.3
overlapping, 8.1.2.1.2
repeating, 8.1.2.1.1








PKJ	PK&AOEBPS/img/ccapp011.gifI>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~,	H*\ȰÇ#JHŋ3jȱǏ CIGP`X	8JʜI͛8sɳϝT|	hʕ|ɴӧPJJW WPVygٳhӪ]˶黰 >9éd]	̯LaT!WV8Y	(0>̹ϠC7}܉o@f*۸s4u!6ȓ+_Μʿ~Yسk0:! w_ϾoCg/[8ͺ(7}i6&jdX^vz0Ӆ,!#~>Ƌ0(4h8θ%DXhADL6餓QхIx=Sc!ٽ'Rf`2=SdAt4pijy+@UPi9]i;*1(襘E(Zd);}+~UD)zjUEf9Ъ@i;N
*9j֬ҧjYFke!KBZyJQk*$j&"kUЅ	vޛoBR%oB@@ЫB*&0ANA(dѽ6,MlC7Dst&M'w'KS
M&@qT ĺQ|^0sJlyM(d!U0KtA-cPkAPoYX]Qldu=C/LF6N5BmCCU4AU8?cnVE}yCP.z?@S_On/gN1EJ#;;u@m{'?n}3WbvsC&kO6o5KM+/܉ oF-j/ƅ3"U`[ç.w\?^^lRW|eIqh`Nh?Od<y:#;N4}"Q\g&`*bC„e=b&@'s x 9@~d!h[!C>b@=!iH@%+!)_[ πMBz.>񇖚&̳{BMXzx7N{ӠGD7tNu`qVհg=*ZոVi^׶Fum]FvxЎMj[[&vW!n{Mr戙vHѶ}gηo
qFꝑE<OxBtT#pXwJKr|x\WqakBoXڑ#H9rZ>tqo-Q9mY6#1́^r|K;<y8˪n%tC}E//bua}!o`W?j\!Rv=.,\JqUǪ`)
ۅg^)aLAphT.xQoFWH[֗"F8_+=|eҊ1zvH28a+>& SJKqB*9j^ʈ8\/(Y83<#[+AwqQQf˓/Zx8zPRjb^B!iXs	|(PPI*!pr
?Ryӑ
)Hiv"iecjcK!A-фh%#(C9,̸mؐoٳz75D2Tx2]),_a'N(T!YrїQf@i)qBa0|ɔN	&ysdهdȕ)_A%'e)qY/YAqCf@0[HgMy$"s#A:8A՘dity/7iy/(AdK D47(,{)'E!atC8s4 {#"fHE؝Fѡ ":$	'eyUe:hK1u9
¡wIᤝȚԧWoDZE(_/
Bb2>q971Bc?9E&&k,
azlЧ^/D7cM,*8Za!yL[`Z6kgIҔYPP+Щ9	~*ZgCJk,0.R%( :#R`ǡuש2Z:,Ǻʬ*JӧV5z8ʝؚb᫲:4J:꺮Ӯ410>z^Zگ	Ae0([gk"(D(J;hp&{(;jgb8ñ)0g,w0
@B;BpY&2{4k:6,p?KZZ00산5*h\rKbekt3~w
s[`}NAȷM:u{;mv帬L!,(l
s _MT~,тA?A	ZH*{v!+k+Us!Jн+$
<[{rJW뾺
J;EiGIjw࿩J00@,Y{?, \pP0PLԻA;%ܵh6P2/ly+xt}>\P,6
`
E|LK$ll%>
,8	M=++_p
c\p0Li&.#g0|ɘɚɜɞcڥuLy`	\%<{ \˵<
&aP{ ڠ
ِȋlJÑ*V|lyNjw|ʩ\@0pxۊmp:!n~XT^g@N[]>}E| QN腮qRpPUX9;R!e!uEer.嶭ᗮ
~Wa{;	70@*:\e\b)N+ջN齎>5pph~a{pc ks=۾~n1^a^}a{7>Gdb  9!~!,}	4Ō.N4>Z9 _9@x_z"!]]~dGP`!۰#Ky

y?suNu.(؀l?_RZMc	wO(P@	.dC%NXE5^SG!E$YI)UdK1CcE7.	 3hw^z͓wڱ[N]:t̙+Gn8q}VmڴeÖHCNy߉e&\aĉ'Λ|'|`lG.m4ԪWn5زΦevhKhmܹu]Qb'^d㇓'*/ ](SRZŪWbɚufI K.B۽ϧ_~D@?"rαo>N4Jo,hNyt֡ǟDSTVtE521k1:>ja;%XlXYE?
⠊N1wjhKZsL2W䲡Ѽ4ǝWXr*HrI{H|25E1UtQiMuRGqeJh50ŔSpIx"GuV\-56@J-b}(wZd4(WhVive׋(:[k5W jUwQr6_#pݫu5]}w
xy/wgU8Z~v8EUb{~xEc"wX"des'NbRk{eVYci&dLFOLWhju%:RmDڢw	(雌	wvւ~{70^ZO6@n;ܻ(Јq|nKpa6R#7:$5
*7}'gzubW\$o|\$+0rۛǨv~y%uG^#{
baF_=~qx_fӛC>$/{-@}TaFVGs_A~t-
 5lPaaXćQ·9!ľ@xr)"bĖŅ0cBCEt]/-!"DF<ˍyȐwl>}uD3'8E{,d%#ReRd'=N2We)MyJTmH@p~hl-6qK\Re/$.Sdb&Sd&/1+[6SӤ&*?Ff6	3G P#|#^gay<_&d/ID
8 hA
zP&TehCf8ThE	jMY
ԢEMѵ
hT|hyR0h*Y$;T	@,0ʨ>59JZsR8A6老;DƎ1**0|.TZ&je*,W
jAvLcu݀AD#Uy]SU#EwLP
p975)ZO,Mh?>x#e`g@G,
v?cw81D%ƅp]҄L,VK|ydva4C:s,`39D_ުz`6Ԣh3|CgZEt=@tJ#LxY!E
Qꆖ)tBΊT؏jvDalV-Ҁ
AbB/^b~M}>6CZnHV=`H>}O}G|ZS87q
ϸ'sӟ1,	+O0z7OW P']4\Ey#4?uB.!@w%2v:g+V<zh``?Ҧ=DiNdb?mnnΫӦC7B.˕E"莗N{¸"M@wwWڜbB%"_ܰygWwϨJ;O	:{Jn 0ӣټR%ChwENOz@׹"<߱8hK@!%ӋߛﳏKp>:)->J20HH;	da0X3F3Gвk'1@B+q9?HA޳AJ@ֲ{$泻{"2A0z0w+5b[#8AAX?h,C>$#HY@OC8'K	*OVb00WBkGIwDckWpŇBr;G;yZLCw)yt	,G#>ÎҺ=20'
@AT8¡>UCbwhƻci(*,X*ULP.G8)!X@['(5=%+"$6婧ܛ?1-lDض[tƃgǿ(oTz\ʋ(G$kgJ4ʈpGGPIIxz;l󱥡IGGy<(E@bø}jH)D-NAOIQE{YۀY7JBɴH#l	ʂ<KLLӪO|'\4D50kN*$_PEMpA8KEAhW	IȦKLo7b\l\u*qΆDL4kȐ'x$s͆MŃʼnˆ0B!>gzH̾`ݛO3ͻzqL|Lgw:	OA\OSDC)x9OPњj&̈O*zNP

Obq+
UML\L

k.[ko'(1'DD(`2
EyK>V:NRNCE{%52O!b$L=8=)|Ө+#BNϡP=ODT>)O|%ɉpPOlͧ-5Z<P`US;D
yĬ|%>L8$3I%Kyi):C%ܩd'W ׄU)=K
*!K;$v589Ll#
:[ݙ(JU*7QEW؞"euq|GN]SYsj@)1*) `[-[=[M[%[R\yIxd}X\A>Wthm+B`7HʆxlKJ0
O@(Ϸŋvq~ƲN
ic	X*7z?DЈ2W@pWp~6+FU8YpE~jоd!ɴհm֤&LUT6[jtQ;iHhcs(22iѹ_V^.4bdPk6މ\|aL@lS_YknHl(.Im e6S4}'vT.nlv7vvyET0AlKH&tvmFTk#Ɉhnpmn
V߮
⎑!#]]7&OߏDXoooZnp9q(q`q0pYݰqq1rrq
2q@rP`p.op*'+
,-Loq)

"35.7p/7;0BsݸssHssstt1w﹮m/apސt߳,5SjN/nSg=-o6WDTh1C/sƼuru "vr4sFr*Gv 0vs
ʋ;l[0JI00ǝ(lq!1ʒY<2{c)ļ3YPA:|>"4HK-/4xy]s;
5qis06[@6ݮ
y3u
67a1yt+@xWZNԔk^0הm9
C@Ѣ|(c:xJ-[2ԘNջ?wL|T|0.x0㗿?O>vlbxcU0ƒ(QQP'`>
>|[h zX6@}/ krA}d2
pԂA	q%%{6a1b(Ḛ7G=aLE;P(KnK8cxQ"IR|X"=1yi	SE2đ
pE7F8.QsT^Q^d}c=9Hy|G4f1
;в:%.u]AqP*p8%3$vt,(I)MYL Wb:¹u#89̡r89bӒ)Gќ4kR;MqL:xcD=GOb01*eAvS4':iv$E|nԙHG
В4(J[Η>T4MѝrrjH*MҨD;&%Vāg2YU^Vea*Pآ~+`F5ih3?	1#p%%Wה%y lEq֌42B2 C%\JC&=(APD(Z}
2$öbiJ-ubb7):YĻxnn^0+wo໧9\E췼EU[`fk|}{T-+YbX+28
$ŻьdmׁC9.+̑	ae]30D`GdywcvH`ĕ/e隡^|Zľ/g853gyLv2fFzr6tGh-Fbo,fԖ hD_j?^PT-% a5B#`Mh:ψƭk
&A
	Jɺmg#6?^x̥63ӽ67f6z;hH#3z^uA@S$IE@6Ids
t!iVo!h,"'qz SZ(QyD}ZbQ=G\ո4:q}:!_T')Qa돀?~o@Io\j4WIw$bAӘz^sG;o.)<!E;ZQ'7S#l?i5OuG냂3sJ	V)qi@}D STC4ph83fP1?GF$doiYgԨIrk?Ie
	?[D7 D|[e	%E͙bA5XCۉDˍlе?('D5;3B_ޮZ-X׃E!A$9	 YD||% @Et[D~BYHݘYJBb5\>v %$bb5`!N".!9I#NB 66d%N&שq %$b$`GA6)J
A	L%b)OQ.JʍE*ʃ-6nAd*|A:f&C1ΔD3BDhZjKtA*R*DV3 
,:$;/hp*|*RQkCԵ>3$ظz);ԃ?+Ә#ARشTZSJ4`BZ'Dhk
,5h@R-HJ+ʓ-h$
A';Czl9$A
HjRx(-,<-,+,C+Tm++B/.9pR5C9,:<+=8XC2դDA#B<٪S:ă=ڪ=C:52(䒂%B)\)dnWeڦ8.=O?C<:S8hB^PӂY8:C<>.;PKXtN<I<PK&AOEBPS/img/qcatwiz1_newb.gifglGIF89a+tRopv1cSSTإ|ϝļ雛Ŵbbb--+ItAA>LLKkkjԜ:V󮮬򆖸jka#Y
fxӣF)%]޳"zzv$?ttoʀnQ*G[Bf_۝^_[հ1Kܒ1NƝSTFƞΫѽtʝϽ⌨ֵ#k!ll"
OO𤤮QYyrǗab!,Q6?+?+?+ LFH :*\ȰÇ#JHERfԨQJF=Iɓ(E"HQn0 7oĹSgΞ@JѢJ(IS%VZJUZV&KYMҪ]˶ZM7.ݹxݫ\'~L8a&1@L
 g|͟CBhӥ\Xͺn]۸so߽M(_μУKAr?^@a*2|Iӟ'@>Ir,$,xqKrP.)XגIh|iD:gfzi^)MIGԛJ	_~QA%TU)RYaW]Me堣ouWZrU:!~ᅅ
!*dH^h,&kik%\@㮾#H\A
[ԝ	hA@@@4L`,9T7%a[T1X,	P/̠
-8G4+%HfA(0VN
#+wF/_驥ee;\Q-5ϸU>7H6W	_@b!Rihw GQ!Aހ@RLp 6(XMX@Mp`6018BK*ZpXfGF_"zd\&b@L\<4UcɠЎlc+X:8S/zuV[Y~Tc9k=-h
YX%UjWi%IK:ܨ9̚kJk笸]ր
L(+TV
|	_	4h~_
E znD':	kL`@ 3:$%QpU(
8X}1rʤvXMh?9IU
J_:%X%|vl	עn,h8뺛{M%Q>
eAr3LL5
;~H;_8u	SICYզn"e:lʧ;]3ԷJ,	+s{^ {-ꀇ$
T x
,
`8p=KB	0@_,<;ZV[pr&(3Rlݦ&7ɛ4N`7I	^`@Ngdܔ
Ns8!hSM
hO?-7	mde}Ll'pM pQI6&|AɴM?4ttG*t5TCuZ55tO$6i]Gva'P"BBiPjPF795 w0< :,8F
0H)el.%P	mSms&go[4f&mmZQch(B >6 2,n?8hhNL
\S@]uaO]-AAā] ('DP%jB^T$8`DRPx/A
_4#0W(1Tãqb'CB((3C?<P3u()V)tzht
$i"Wi+i 8^#HjB'BՐ*PE9!PY^	*%"/04Q31ǘ*QB#H=`1 c\(#pB!\ƀPPG**a]]	j`7jfɱvAgg92@S4S{`{2!@3yI3|ٗ~j5)39dp阈阐)4-Sә9c4F:;dĚɚ9	L=vYf	LUGeGy`^}Gv4GtؙivdԝiLJ[IJ4D[9~tIٟ
;X`$p*W	*Jz
Ƞ$ $*Zz+:(ڢ4Z6(*:0;:5j7JBJE:H
GKJy=ڢyO:SjPB*OZ`b:ajFJe
g_ʦ[jgtZvzx:(Ȋ~ ڧʧ`-z:-"-E<Q*-*--:Zj,Z,:
*z,jZꨔڪ*JՊjz̪:ʺ՚QʪBj*

κʬZ	
۰8)7k5Q44;$[&{(*,۲.02;4[6{80C8>@pB@c_:۴NPR;T[V{8)P B`+,r+v`p_'K 4 "tk3{s[|۷~~˳]뵉S=0r A;F+H6l{Cw-6Pm-BQ&k벗-k˺#C (ke2\up][{. л$K 8#@'CB$#C8{E-+k-#k8&;
-q;k}}A070˸?!IKٛl!`PX<9&Q@-CC\B@pE!0$SнEP5@.Lo80@Q0Q<8LKBDŜ# #EQ`k!
] BĪ +@8 ]>L@<e	<?TLP\#Enk@k:R #P̽L>@9`1@P/ pkmC&\oE'<P\=	B4@~"ْҬʅ*=7۸2˿7< k
FoPHJnwC֩$p‚em|9 p@k}#{L}m L`?v\I<0D=},L?KRʫPrAl7kTQ.kzYc] 8L4QQ8B8P\ 8Pdlkl$n'L͝MݬmC9`,
D\^ηmCKJ]AN\Ӣ}C@] \K=/nz#';wL4ŢnZ<)PŘS FCp @. M|(Km;*p$vTlآBP\R>`=0.}4-ij˶ƺK묽QP9آ3k~k,kH_-~6z;宻,
,r0 0@|v@q ?$?_C`;uL+%_68ϲaNMlF𽛛D_F'OJ/?_kPR?T_VXZ\^`b?d_fhjOĻn?QD@yZvxz|~?_8@X\̌oЍO=Q ?_?9P@?_ȟR__9n.zG85 	_lk4ǯ6ݏE4/V,	\#4F5
Rz8
z
Dz) +$6
չڇ#*E۹9#E*#!
$RqJ!@BB<07/V*1ְ%#EH4AaŎ%[E]xA+YB`!E	)pTT^2YTA
R[h94$XnCWS4,6T zM
#@9t
-hOPa"hu#P@!/# 
3ԡM_
-À
k=g@2Thlfs,``Lp|QhXJHh\kʈI*U?Cզ8$(*CA[%c+PX!WqDF##.c	`_WDv&Ht)0BoKE*8	(4R6EAP~S:ʼnZAjm6$b6H$@AL]/ɖ+U`kxP Ѓްڅ
	!(dU	| `Q
lı<@ve=
.pAo1@…!Fx
⪰W[Ӡ> !>j@-p~7XY8yЧJv@*x+*6k@0
on
%5o NFaTP~o[	|@P.O0	$m
#*
uF4l]P(lC%ݐvͤX#+5Oa R{7|RpWЯ)QȀtuc4M	y=!y˥tA;,3@k;# |
	4qy߰yBUm^5@++vcz03D
qNo;8e0 5 ;T$SgS1;dHDD
]F}QzqG`%0N`T9ߓX
 \n*6DW3x
cuX/mx~؇W:ux4Vb!:;tO	Rtp:tUHK@B
>`䊭yBWpPaKQ؋8Xx=ʸ،%H8XxЈF]AHF08Xx蘎긎؎8X؏HA9]qv`Y
yy9Yyِ ّɐ!"y		ۘ603V3L`51	2Y4y35D@B9DYFyHJLٔNPR9TYV9-i:\^)RP.fٕhiA
P@:r9tYvY?)*|B~Y'9Yy٘9Yy#FprXn@ɚW<G@U"@0Yyșʹٜ9YyؙùE73Lb(\(}0PG~N	ux-FqRFe:Zz[33;3i;Pv5ذ	`xH	Q2	9P<(#	207j͙<ڣ*::D
H˹5
sؤ@5PU
g5(
Բ
sLs>7!FS~ va	yA@`T+`-7ڨzjG+:jEU[M;MHˣ^JkXKVYS{g\PkS[k;Fkj{ʹ5LGC 1Yw@ `oRK:*-.;`t+ `Y. iJz`;" DfC"1cQHAJ@U2
aʼz+*oͻۼj˽K[i+;baPC0
ERN4 M*@
-TW?xc&2?4
AB
U! 8l#bfE8%~VAe;:3BK껼ʾ+HZLkڛ*[_u[D?|f[O|CęʤNH" !0auC5{[b<5Tf(].@^ordg=]Ecd
5lJ5Y{020ËכHSL]Y;K.&8&z8>y50b ">2
}B "2'~?R7)``@90x˯]?=n;l[G[fWe\{TK{̞CqZa%U^{4^nd]"}b$"^QpF(TDNr8{Ҡ|-25ٶ}۸+	AhNКaGj9pބ*6LP=3؝ڽ=]}F`]cX:8CD
Q$
K^~ ">$^&~(>(	X0n$1~nFc@>@B%YD~&FHNPRST~VUXZ~Bb>d^@>;N3lnpr>t^v~xz|~>^N轠|$>^~.n@>^~ꨞꪾ>^~nKF >^~Ȟʾ>^~؞ھ>"+:
p>^~>^~?_
E)J]?`}1(*JR;"68:o@8p4;>@`;HJO.QQAWDY5VX COd_f%Rj f\VaVi2I]㔣`D=8%F}O2e"T-z\`l^"'Gt!]ygYDDf1zy"\AhKa馜R%8ۗD	<ձ1#δTaډbUMtjйY$'I ekYb~-|vܚ)\2*D6x*0^Ŝf$Wli%snfxVlSwqTx˹j+jJeEV5OS1qry#AԴY'߆^Eߏ\Bj,i‹Z9qYrTM+\wҮt dqc
F:򑋬đh4EHZ̤&7Nz(GIRLBs<4b8,gIZ̥.w^0IbL2f&SqY.ITA"̦6i*8IrL:v<)MQA
̧>~
@z>/MBІ:(GMJͨF7юӠHGJҒ4+Җ0DAzj8ͩNw*Nz̦<
PJT-RԦqHuTJժӧгVթIXJVbeMZ׺ѳp\լx;R	]AKMb;蓯r`Zͬf7z
hGKZeKkDbmlWN#t@ͭnwַ\ϺuR(B2΍.t+R.vr
/u74BbCH$W|K)l+x,TT#'L
[ΰ7{ 0T`NBV!ט(1Ԁ@HN$*A;OuF`m.{`L2hNfH0ė!xs 3 l4#HtD@
P'MiEcnQ-jX =
$R=u
C":بcI#J[@
MK)]]:jH<`H]sΫF'c$# q5rM 1Fo}hIנ;ON4‹pX5iOWYǝ
`!pDA8%(:&
E6AnÀT t-@6(0=EUm8v5on[xl@+{I<[48y`Aq!(B,l	$fK
ne^
289ЁG"
* ,>N>C@p>8¹6q^l:Vd@C_`ސK:@π\6v$.O@6~&qG@G=
$"T!Tw,d@^,!Ǐ G@o"'"F3Wr&6/a@CTӧDDrDF/VhԪII#c_+Ձ2=\9R[յDpYu<,’$K59+bU'BL=AM w~ǜ~Me]H
&Xe͐Բ 6ykt/r&Y<҄+ҷlk#ُk	vsw6|Iju{_O?οǑLj\^ t䓠~uSl
SmE冔Rg≝HO:MTU錳$s\[و\]`{e	@ג`tIE@ h啜`fRrQ)ED9ғlFnGxb)}/$vY9Ccw4rV-^Ж@ǩQ9LVh"4!h穾X_|"QHC|.qD!}#@NXӛFF"̪"BY8 QKhNk{UhZyd0n%ʬ,`:cjfiV>9ԝFp-lrI4щ{LuaIǜs\,FRjQK2"-`
hW@;*e'6\,awK!̱A^,\y%]gDlGEtƅt'WKh{)%`a<tI&EZk82MmFGd1jw^)5t1䬏"BPFW;;P8i@P{@Bdd܊8tH^%׭gЏ8Ӱ/Ik-dL/pO`ko?'fp	L\9zy`LBXb
TD:2,//SMw$`7	=ئoX
a%3[zdQ"j?,2*HшA,*rW@"G*).
KֶîK;H6pH:x̣hl IBRn A=YHDZat؋*!̤&7Nz(GIRL*1)	mX,gIZ򖧔pK`
~q*cF^L2f:̀,`hR9gD
>@|TL:s|(޺6S@|І2inu+{ (@_a8!0R]j`v=\^jx0ξvo0,h5pO8t`
KOS,4׳}ޞ_W& hPd,`
8T1om6-j,➂YXBOGP&`&kB}O:]&@A2qVO0R7ѵAs-ުc-<2:(

&%k4TA0_!!>xpw_(@6c (!8(@@7 
]|(|8 8]gdxřXy0g1`4DECQc<
,^2<@	 p|`
a򕀧I@?@{݅	`5zƅz6No, F@`3ֻ>ُ-[6d9i
1@]){xǥ$MS^D@ Q |
ֶ(H ih#`Yp 1\Ѐ4t@>x@c ꏆrzQ@N#i>QXBo~}$bo0	Xf6(Z4etgy$P
rz5pCp^n7'EI`.tpTa1@.Plm.]bP0P1`EWN6F[ f> ]LPc8EcEzgeGnwhXE;P8uaobcn?M}E}Xofa9(~bwRu7+]U~7E͆uWN0?dx[p{#Se`N ~	{Px#5R0L0w"X#]8q,h|m_L#g@+WG}O`0bipPuDfX+fE{]td8[dWffm.@n'PBzh=	.`иSHgXҗ)gUl:{e1aĉƧcS0c d$]gVemtF7eps>'sz~oPvEN(Nve`EBsQ1{)W[Sb8V&eNmsX	^fxLi[vq${5B0r6Eo>7+%k7WND`B6ni|La gJV#v6NG].({ha|0A|MQ sLVPTo.ejF[iz1pp{١}a_R؈ʘXQncFfynW)wxN_ǎojP9YFReP}_uUi@^0]8Ђ)Ŝ}XؐŅ\E?D: `񹨯ǔ1EPNN]V}V])Zȇn:|*8U `U7<`FՀ#075fHNB sjH)lfyP`>]aPf]JaEpk>WpץiIVhݶP< nkdI@FP 7[ k`?@E؛d uP}:E@GgVmPzP]Ed
g7r!KB@`ʞʨF8$jT(]ig,:|+XJs6PT{Nm	E7_mxdjɁp[wm؆cfaa @
r-i:E0_B)o#r߇z)YpHq]Хgsc SqoGP5fPOXSz	P	an oS0_: t]'u#xe^0dfT9a+jys8&(]r7WE@TͫG[F\ir @Sq('NisզK׈j6eWf`^E\YTu`M`jN^%`{oF'/l>W'l+È5`I{Ue[S,T|VUXl#WVPXYZȺ,6gG8WXpaPuTgKTpW8Wa_F.0XXtW	K1l|˪Z%Ew_K\PTo0Y]`.C|u]Q^#7Nr=t
VEx_>Ym^ש^[dRS<[josNTVy%e6hgwiciٴEgUb@T<`hF5֕g:l	0|eGiG5zp	]rXXN?ϕh3z?],A\xiy W}  (eQXQtpYuqW!7r`r`=U-'`a7gἕߩkitXlVӉjo	n6zN6Po4ٕE+HaܥB#x>o䏵pSΟ9ҋu
J>giЖqiy)x7#Wss.*1eB Hgap>ǏSNq`PN/Z^0
	/ڥS^}=9nh
	 nxz&J(WS6P[oWx&Gd(BEN~c7zTPi\Di`@)# ׁ_sub8v h	3+?]*NC;XG?0W\[^zN+0ZNZ#-;?@E. 
BkmE	.S-o[ZV	/
zPRW5Up(TSP.|c(CҰ
!

>!~FJJ6Py<'S)7Q|*c)JN(QͲg%0JR1'eNt)MYR+&/Yfr3j&Ӵ=q^d&:Y=r'<&y6
ƴ'שճ6jF~w3y\I(2&	x 
-
Hլ	h5w.|g9K
@
'AgEK0iDz҈ժ<`$MD+ @h_
/5)@i]K4
"M\#ա>6hGuݮ 5l{H0% 7rLwA7 ~<tnX<%O[ϼ7{GOқO}k	|^
}UO 0-~@CO;ЏO[ϾL@$o=@Gۏ1HHsЀu`zh6Xx
؀8Xxhf6f0zp01'h:(@(B@l&VnDXFxHJL؄NPR8TXVxXTX"KJ)7dCEHlQ(ZxMH9@zw0px&# wFxxXxXdhphH 8pj8sC D&z#4@kFv(Hl
xz
 t x(FB&*0~v蘎긎؎Z8M؅7p00@8j@0$ @V槐@	@Lƌ+.w@tzz`hzEoB8ٓ>@N8]&ep00C0pszPn
@PQ@8)$Q`3)<)D#`ˈwA0`^`(m>QE`U閐9(FHɐL	0Њ`$.gB d8)y.x86QMqV`mIڹٝօE9G9788zl.4EB9nQ@縝pIБf0w)P)2	1y(Bi≙iRٔ)#
P0Q ?*	29#sٌ	w()]2hg#ᩢlڦnDIef)@ؔ2EHl)#5Z$t:'ywjIlp@xY؋ڢs.zs320PE8zVYlJPHԺl:nڭ:Zz蚮꺮ڮ
`H)h:iJZipDj˭˭zrɌb'9_>0u ";$[BgFt6@l*t-/P&{@ ;kf:zzxD[F{HJHfwN;ofL[yX+ge`b;d[f{hjl۶npr;t[v{p{nm˷x+8_{l۸;[{۹;;PKl|ovggPK&AOEBPS/img/pet01b.gifGIF89a@	1Ｄs	1s122CcyRk11cc1Z֔.n絭ZΜksV+nik&c,sWgyϭkkJUfks֜BoQs1|֜ccuҜJ{ӱKJRBc	J111!TRk8JRckssRnqLR=e1c1cƭ3X{d))c1c!ZZ1Rֽ̿#,s~cc+ƫ9J{"'!cϜ9c)J?>؜s1RZR.!r!,@P77@---1ccbb7ND
(1(NJ
ʖH*\ȰÇ##ŋ1^HB=b+NR췲˗0cʜI͛8sɳϟ@
JѣGO*]ʴӧPJJիXjʵR'(*
gx#@D2	묻x˷߿LZkB7ȅ-Ԣ԰˘3k̹Ϡ&k{gdװc˞MVͻ߾<
?μAnسkνËOӫ_Ͼ˟O~PX?y`cxT/^\@_
(^p	.ؠ
l($x0|@
IHN7u$z"/~\*WJ*bg! +KbԸ.dW9e3DhF@&4Z oACp772)b-YN1={
<1N}Bhz`uZsr{g+7] Z1¥%1x1{c!vĝ379a!
kL@%	L79g:-G򦠾(Bh[?-*Tkd17Z=;Oބo*V|aq(*:د6M>stu\.R-tnV@Mem|@B0!F#RM7tݫqZբ|Moq7\an׮EHq8%qi[zhauoMm\50Y.
Jʢ&:.n~ӯ4c!0>iЃfTj7G
㖻8h gGLC'hr|V3j8nw7D)MZÚׯd9^>x`z;{Aڷ=W3ЏYɗ~zT/:K춼z>{xtzt|@"{}eqKG 4v	;|z?b.Dn%reHcK6Z@O][T4/t/V~P~ڱ~[k7WW/^4Vkc4PzGtmcp[aztN[{u{6|"n}u)(Ld7LSLiWZ1P,vv֗Dx`!bwcBy3=pNSϳP>< fFrGS?$H;,~SX@a\X^
`(d(f.c]GG-`ȈSg(mjI XHPgpY.VPxU1!%"RLw<(>xiJPx
EuYnvB!*;	!;wB-AK ؤ)	L7]`:yOko7h@e爎JHlHS	FpV8teiYUpr	 ETDvr.KRTo|	)A.2qv#R(-,ɋ&auraIW_`d568u:Ė&cCuЏJSI	DU[G6Ӹ]`sٝpY%Ag(Зvv./$0vqruB`|-;F
	w			
	hFj [#|G-GnQ~xРY	JY!*ԍ
et1Jj@B
uu2zig 	 gKڤF	D96ᥟ1piCz
@%cjlz)gpuuhA^.EuJ0V:L#"Zy@-`L^:MC-Pک:ZѦsYq_ǧ~֪//W:*_A:zŚʺڬ:rS|Ƨ-('QךK
:Z"ǥ髐:ӚbH)G;[{*cJR!jk(+G(@@$;Zz:*qj2	[3{8:<۳: E0D[D{H00'BkR[I{K[M0P\]^˵b+0-K'jjnp
C!CsKax{k಻ q{[
ڱ6ѫ,	/rq;[{ۺ;[{ۻkqqUۼ;[{؛ڻ۽;[{蛾껾kBJ%[{ۿ<\|
ܿS+0\  "<$\&|(*,.02<4\6|8:711|<\F|HJLNPRMl
l09|
ðLH:W
Y=g`J}3=\[nօԹlDҩpPm-վ,ʦ{XK
MyP-
LG]pK=y]O	Φ
Pmy-ϣԾ<"lΠؾ|ʫ	`pOw̜3ۏ=|xԜC
qlW,|Ьݢ}GRmրM_3­2=ʝlMLN	S-'me`˼M@ͷn:,,=!^}]ޣɭ
D^c,}p0~ʜ+0=O>Y>Ia=e="
Q||"pآ}iC@\:l4~Zx-
|]"M3Yn
~,aNLeܫ-imQ䌌ޜQN.کM,嫝`잾^)挮	>쩼–n^>ѸٻܾkMε]-HLlxΟU`n$̢i}ƞì-_׮ӾW&_-ݮ$0cM<\]X~RIf@:p{.BQpQp.MCP8^,o.. z_QP~=`Ljn<^S?OXX#	' y',~7
 
oLcd)Ϯl/ھ?j?']קU)C=B+=Hg		:+QE=!$IQŽƓ˂ʃķλ֡ک	I"ߦ!2APs*\ȰÇ#JHŋ3j"F!Lb($O7
Dh(fIy]
22LdA
Qh)9psU&`vт`'5pb7~KPa_XF-'uBSX]XEv*5yTo)s5JL˘3klKǏ!Gp S^ͺזžM۸[sR$IAKBȓkУK
wd&3_yO3_dg0DS
|@=O&LD'JъZTH zQ0iԙDJRLv?%i	fS fJӚڔ5[CM7vӛ	`
''j0NNҸ̜j
97S@9:U`*U)B< ZL*;wxͫ^W~ԍD	Ґj,@R&u1@z54F"HE5^==a%UHF-I:2q=R';YsPsL!wAUI@-'i#h:N[>zn_zy+XU'2.]
#:3o(5)`n|@
2۷?6:7=eҨpSXԓ<1e 
 lb0a
Gj.EkW@2^GwK#(	0
sֵ^s!FR}n" M7sNYxip:`	DTmm.AHC\:C:]s{ItmiG?Άskcu$GBgMk>Fv-#OIf5%(̃SIItְ{)oI`yl]AwUSpj&'X0+<t5&W&aN]MwQ-E`śi{ɹ040=i_t`]{unM\&뵯$$	ƸKeF:u:K|.\ڪ~0[fiGd~\Ά&tͽÓg
;|ɝ6˰̳jϠmqB4P[${?=vN2=Zi;=v(N4*mO(ɿ{<,5If{5k IIeT~.Z#\2vw2:_~N$[o嶚m,|n"د<̙ק3+
 5!Mh弎ez,t$>5h%_#SH-l7q~X]6Hw7Zeqj*5(( 7wybxǁqbq(7 8+(')H#1{D^RXbaG$`	O#A8^2{~	l8g@:Bbs2PF|@ULJ_7tItvS7`wu77hS}4gi~3cl5mhK5@7m}IT¥jwhi-5F4u?3t8qjua#{"yhpy'&y'( 1&8HW7wWr?",#6?($G{?F%HrKsFc-Up7|evw|}C}b$F5#F2R]ߧ2xbLJ.(CT0/\3'Za55~L,wQ853@'V'+6тj4)ؓh-HX$I>N)LI99hy5Y`銱fٕ25Y0o–Ȉr02${D2zIaVyHAO	,ٍUx%-$@diϕ*i@_GgmЗSf}+~4gvԅ9XSO}w0b#TxZ&U 5C#f9f-STiX&pɒ؀G}B=V)yS9\ɊjIGٞgiٟTynhW	_		*fYH9b&CpwY6q=A{``I
ADu>
DML#i@#Ц_cZ9hkf
{k$뙶h%z.*T&`m$
wצxDBu$h,PIP=Wu$[ZK74abܝD2@*2@q䋴jH{R;:ok
Vf[z'QEkLdnx	{;@3 ̸~I,g88$=^(mt7FL,C϶wg9p$<>S8Kj#SOV$45`p
4+k$|=C+ ijgyLKl۠zLz+-Lk,Ҝ`oI",Z+$	`jz˽
E&C_G-ɼ#-g{7Mk9VYۼ޼mZETaN@&YMCOVlyL=v$$
ց
|RHY1M}$٥[yFi)]kzH	Zº2mɫ'r79
k0{樝$6}a,$lM&ٳ-LЌ:y(Xsr Wy`^#^Ɲ<ZJH&#\N%&8_7[juӥc}_X3:ެCGK
I:J"Tu4lACU)5]	MR_>ܫ&5((x{EDE"~+$d9m 8?^t˗|An\$ܬN?=8囹:̉2Dd>W$϶A0}e#-Nk>$~迶X4]
C7e6N$7C=Zd6:8T7>.mGT^NK`W8Y$>:w}5.$P8N&:gw>t6tB_fIBt#$=8xU{x}F$,C%58H^bY2\C
XR@QS$E&GcHe 3fm/SP\-/#')9{M;&=Prj#&80SYj$c٩4?_?_O_`2O(@rAJ>)LbM-n͌U-/J?_Y">?:G/Fzljyϑ3##8,,K8Èǚ88,-1ABL1J5ȗS8#&i#
H!ܤ,ÇҨYæ9DFr09hAN\ɲ˗0cdJ&sBVڵlۺYʨфKz2XHJիXjʵׯ`ÊKٳhӪ]˶۷\e!l

k`0!+Ãd`$%*Ef(񂌰`<ǕLp˲.F	46-
%'H{bH10MʝsМL]teF}֖8JvJ10-tM,#7]IZi><Ri!B՟#c7'&ֆa	{q{rn閨:^'frwb{(z|c=}Ȧ7r׭S_Qf#$WZ|N#rΧ@17H
	@xpc2iV	Vw9Sҡ!)PVG9d%A^LTհRk#
"
9F+"
b'LbѨ0p aE
0[2:aBo]
Iq5xݴ)kCFE3k=<_HXVԲ,k:Zζ6}(]:"KEjT:gT]}TvљV|Z4(VuUE(C;25}*Tu5l%kX^$
k^^7p{;X!/^
j6<z;ٮSO/T	p8<
+p8r_U7pG]BH1*mjK,W#%20O%X/EY7r]L׬pkܖ"L0x5  \b-[Y;m9I*?4P
fXypxpNzGp8`AٹPjy`I,*i,7ڻIl[Ex2QXG(0X_ԲvKZڹr\$'Ur\8/7pžo~o<07:_P&0w·ޚ{廐yqGuO;T%+mϾ1~U&Ov^pKvQ)|Pv8]a5w6IoGQ-~sA<&"0A
&-~]ru[h,f!GvFwy8`P+k 8rdrx-v2nv؂V|[$yGn6aMummƂ 4Y_VrUl83({qW0wЄ(q冄8x%Gi?)0udփjOI*YƂ*b/(8gFu5~?@t8@]&nƦ}~FuB7MX\^itfNSO]q}0(dk'[h\8xx6r(e (`P%yNX|苓E(eu,(݈x8h!f`؅}ָa4vU0U@V%Q(ЋwRzVx%1p~@\t'pFJHu`!k'm(,ْqV%#SE.c#؊5DDd60p0EkHSC$HIGkMYSyjOOk&`XR2ЋXyE7tY4_uViT`IHeV^yTkvNFPt/h`i5)G	uxYf]9f+$*ƔTՖTY/Q	SjǗ_I)5wRj?}6Y(8r	yc׍FDrtRH
TZ;V@.G{ɝbPy^@	UN		Fv+Q)'*ؘyɖř޷]y
x/RǝYk}dV
RYGƉ!ta	Y	()x%
t()+)BQ5M@h^72Z
^`b:	dzhjlצprږs
CR{1uu٧f:zXڨ]ꥅZ
jwzʥڪ:Z8Tګ::$[APʑʺڬ:ZU?>ںڭ:Zz蚮꺮ڮ:ZzگJM4[{
۰;[{۱ ";$;u"%,۲.02;4[6{81{q5*B;D[F{HJL۴

\M͚K2l_,5E-:ڱ].3.L gNi>|\M=ܑ];y,3lݵ3.=š;bnނ!\TnbTRݏ"L]蟻*+GN~ְ,>ЗƱ)E=m.4
f~.h(
c~(5씬5~+ƂWnؼT
>.>ĩ+N._٧^uN<[1p$;ޑ{ƓK^NoP+^/s~Z?D;!h_DLlon^OYlwy
_-?A޺ROU_k]տ~NG4_0op^o?-Փ/W.7^GɯqW֯AO龼p >|~aK|,?)!+*/!	!;))4	ɧج׳¶ť	ɟڴ̐7C-9ʱSgHܳhIa
Gڶa]V1mk6$=[y᱓(sꄔ@@@L"F!Lb(](ʔi>t!;F9--5Kf*=Mr[%__G2F6NA]vvnYcWLژ9ig+s:[V7)H|,'*i>A*ת&M6e!+tg9UZb=k0ĕ_?k^y$ +hDRLmTU?W`0Åsu$J0DS@1v"!p'/R͇
anHPM04ГJeȢivd!Ԉ2HQFIWJdʏ}-IJ)=b"w0h>X]/L9	d(GngJ*"$g$"	&(lR9^8'<(:H0"'p$e2)~x|^!zb@ʫ4쪝VGc$&:20	Vk-	RPuܘj!QCe)8b&dcV
*6/}\0fAsj;+JjAΘ3:|m=87soLiHZj:Mig?/[	fڠGHʮRMY2Ƚ8̡w0'1"HLhO$bH*ZX̢x!N`H26p#и:50x|9L?LB
"HFya$KX/0`9&9GAu40wÔc5QwTyi5ebH<LLxi@ys,
"[a$cГ]a
AXA_;;B
O T$;uNw,^=)z$,=zxD?
:Zdwt6L>S:,e"BK3Pၴw}N
.{.R/Z>攙
mMQMܠ+jJ
iJz;TPo7Ճ4*N8
+XgNmu'oPz^RD(ot0 W`eWW8[=Ptګ;hV4()vKc+`zR!py3T&Zj#N
N[FMKlTm]3\UJ悛vgm:D:~.Hc~`]N;y+Xí6	oVܖB`~+ߔTc.zh|녱څy3\ּ
IS;]
Ȯ;*2E[ WH`ہX6\d$
$:cĉFj'/Cm6U%8jen	X6d269^R:Nkɔ%EgZ$6;$;Ŕx`PgkƘ2$haٛhl=O~ib]rA?4nF	6QvG}	E'#ovr-Ay~~{P
؀nfuJZ8umSG
d,+ͫUǾOIeNرN@lge"@Kv2i	MMx2LC0[Rw!mO|XUw4H.woP59g=eg`qIK	6TPu߻qy3a'RkZ~yp`UZaxW۴aǣ~dxc!ɐ	AJ:!ьD$	Q	YQ0*Ȁu,Bы1 )J~{(rC"C6i,/mђ89xy*)7,	
M'}ilfF	Б
|tF z'Yq1WXPNdA!eV%r,z"s}y+oS*
^]X(@=%9R1+ӘP,•*J0hc,&dV"@f|WIs39!i0RCX*V!)9$UrZ(bӤ4ylu,Չ)eEᙖ(.RƉ7B>&W/1ũ+ߔwzT:B9r7:7d3/J_!sX	p9%}3\EDc2NV54p@UvK.s7 /`J\*7J*oP0`ҘeW:3ϱ
2Jh#$(b慤L3 Z!2V'+y[[PS5(5a0]KH33v*JP=c}(:c0h:%37.:/0FP#G=pcCq8Ć©ڳ>J@
G/BZDWJw{?*	ct
B>*#yI?JB+$;T
j>zC?݊:Z<Jگy[{m$۰>
[{$wDKfTVMO-o+ (?&;;-˲*K;iG1A/; 5IOM: TjEx݆CJYU"t"+; T+@K;W?Q@vT\?L?A,;F1+q9#PPOP0;)&CķBS[kdSPU$MM*;5eUTN@9S&c;qiԹwmk+mkDf%|sVkn"UKsL'5u)XMs6GX(QstZvgs(
w+sNwX>y|
nH	M"#`ǣq-4smѹlsK-h/0mbq&gq)XA3vb(DtQip#-h:ixo\a})7u ɧأK׌x8)1p%|ѧ|&=4d (::|}4C/~jHmG5-{ۣ~ĺ)QkaƍM'}ڍKG^]M]p뜤8b9t{:,*1=~UaAT4ߨHgpHWg}c8d=i}~yNvgvݑ@~5&X"m,Cs)Fロ>~"2$B	-߾K$7Fs4GE|=w6x+A
񂞨ylnhӻcK)ܚco&VH֫yr:OاX憘҂n}.)csY"ؑ-_C湈l-vMUh3q
-*i昍DQy@1pI?ym>f8	nɒ
-E(2/J@jU2ڙ1Jo~	NW)sݙTfns=ycS|*A*u0)g+:]&;Y:ș4ıL=2Ș?+*)cg
 =nߚhNiFXܡ7Y"ce	%+<4bx"9_.H<_l]6Ja
6~3/^gӇQZ68y@wUZKJJC91	*3&#/_SJ9p_RYj9oj*LYW	A"
;,/			;!	k+			)×*eʐ4	*泵Þ760&~ԶUVH"-b$C	ɓ(S\2-0ЃI͛^⴩C&I'ѣ7]EʴӧP(Ջ7v(աҮ`~ahسhǢECX+-ݮj˷MVb#Hy*fSŐY&^Р-J+]\yfd?M)z.nK}[n\M!6Ȼ=>{F}BVɣKNسkO\OO;k˟O}g(E=^6Fx܁%_CՕ2El4&!I!.5(H]5h'~8Z:"h&@RbschqPd5N>)T6VY6
_xWhAYhԕEXϖauk飝j$o2!&HIcȨʠС7/2V*!5xT!]I+x*jX9Z-(fRb#ȌJˡ&Тjnj2ٺ``/5 %c ކCKۼBC*8o-ۆn+&p+ނA)dJt@$خB0!<	kcjq+|/GN`l2RŤr=)(@MZ*{*I+9[4N
,-8:Ԫ#9Ⱦ
P*!l"
QR0u"ޒ\5^|ᑯv-c!BmrM!"&Hl7pٵN&=2ez)꥓=R 9YN:Ez%CI{||lۢ7ڒt ݷ7S7K?-#WNJ}k
O|	Do<Eޏ{ uWU.
(EAۡ6Msj囘8Z?w5l-2R8CU[v1'P-*\9-VL`#œ)K&Ĭ^A(hو!^+QdH4`s:0hkrDrUe.I>K{ y(R/$Dcܼ/m褓"t0h\0@ch~	SI6,R8\
96l~7~&H΋
hbH?qxCOw^A:AC2K4餚ΫCi 2ZZY"G@[!5cؑ[܎AV
sMdOĹa\e-1Db5ޔ,q_Jžd
m]`6NLce"1uIHEgu2v~9010-i[Dj3~#ݣ[VT_;pJq޽3ᴪUxpUbpq'T`X3XE2mf2-ufrX$>ezxyՈZÁj0$Qև`12q2xkW\xY]"zQU|p u\C.'&31VvW`{7!C
d-Sva=j	3`]j}쉯;]dXx䲁s,-9kkf؅c5-_,O`1J~7SS&&	g#b6HBNt8ghC06
N4w99`4NcG/:6SwLcKt8ͣ7մh8;Ӄ#5WCăpt愷&	C*tCGi{r&IIP~DW`}@
hJb9
cA:A<=jcEO4(ovH0dS2
Hd92fv&'N6F2ـrN*vmN"૱
;=RNgƨ
$JDEJ0kXFDOp(7+WQ0PRj#f3/g͢yx	RDoo:vPD12QpůJ&EN鶩*lJ0oz~4DjS z
)gdqha6RC{ 56KI{sCOE#K	Qڲ
ձl`j81kadee12fAѶCef_ܺYLvS}+FRDP%1Pw++MzfeV^D4Vp}ǡIyk`?YuwUSodѺfvdۻ
[KƛNqp;b6ӻի#| ̋tF/Fv&c`qdq}A!ccv"4{*&aQv溶f)`SKLNAf^ƒ`~fQb#lhkkքEz(ƹh:	\B)tfzRAf֝w!i@Dq¶~6Uڱ';#a'wai.JL֩`#ŠvNlmcP<j$3n|or΍l]WM/Hq+QZ:
{7{'|=0`@{Sy	#Ld|yq|'g3w
3l%hu$}775s2(]Mq1w,9;0|xgvLO7t)g`IZg~4Cvz*+cG-R
jgX3.m֐WO%zp{#X,.9Gՙr4u+	wQGѤP˗z-OGx=%I?%>	S_Ь +sS+؉$-h";b
!Xq+ژ}jg:03(}yZ׳CKbXC%,\[:7ᝃèݳiPEeH뀫=~38]d>*z8r	ٍZi27N"*Ui7d>(j>lNufj	鿾U@~URԜ9
ENV_O\@[&Ja/G'kg4WSڅ˜lţu{uxkC
m[Pp
m+-tMW-=X7Kn/Q6⨤s|DVä$^rsAG T҃'RK/-hf ["h%zbL*zdV/&u7h;#BcHbI6 (ĒK01ip%\ji Q:"	ʙbj>ivg!ɧN>IRRRX埈nƴgzhm;NC,	&/|5fI䣡"Ijk*+Q@T*"*ؖF3Il(&cmF+:ev+kn>+dPJ,IQm7G,gwqnZ*&iebDAxO$1
%8rQZ{FG@rGӣ#*u̢DV|(~6/\@-)xc3qxN!&.er.)+-Ԑ&wьp3K2_8t&D	Hws=IA6!j^ӇfM
*^Mj`X8B%"$E	
dv
΀gB0OӢg&#j6ּ<=ЄE_TtfH8;f7+U`k"c_p!"ϥ~~D5"%Wr}Mxd,7ls&yHFchHPP*7e}6}8q7}4/*P^rY$=|jq{Tm!'ܤb&Hf´X`#Phzwsԅ%CȐv0nh8A8`t.@Mxq~i108nR3ZQOO(<քVQUfg@X rm"X
`<qцQـyׇ"5
piEzX
Z&ńrq|[BT$+@1Jnqhn1
!{Yd e3g
RDtB١Nq
8kP>q)ϱERBً#(ȔF @BAa)qZVvX- 	#t !C5Ahր	_daꈑ*َH
U	<WAEǘa'ْ=#G0'#(Җ7t1㲖ۣ>"Bx!=3c&A&˜%☁y.?|	xui/Y2Eb))sc{XY7B?0y-f.h9409R
S-2-9w 9Yy#عٝ΢9YyӛJ>)Yy91'g-#,p'y"Z"vc" 2瓠WdYYY*!zK
%i'$3D;}!#J";&!'%"- 3j3JBeP"7(uۉA5zk"y%dLҤ%r'9i'bS9|š¥7#g"`
)$_)gʃ0{Er<7у"S;)2{!q!'
㥝>bàj
ZR9$?өȃ$h~Z<6.!*
.ꪯ,'vg*xW
:#*CPi;EW'qQQIDReTZmI4vD
8ԬJEt`:Gv@"EB4Hm)IH7T1DC
DwRݵI	fX(GJDHEFdP0EGC8~DPqF-f{UIDE_$JpQ
C;4Ie$S`JDE2fShSŀKfTU0USꔂeVcuM%LĉJ[PW>MmTvePQ5!eWhQU`SE=%Ez;U UTBu
Krr*ʴazE"UM: F;$TdhHBY@8\MxSuUaV	K[PGQw˶LuUN*K}҆dUw.h{dИgYI]|g
&O%^UbaEz[covf^],](]Cv_I{]v{^5~{ZսWr+:6X\WҿĀqQR	^$Ejk6	8؋{¥ua&udDbM;
fKUzvN[K-	2ƎL6'/v!xwy2XƚƇFuKVh05nvihdesQrHOI@Gi@K"5w©*,yZ~ǻo$t~^vosǥj,9vf``wH(>>øANP܍P;>9}W2		
YiWEɱ”\).+*kލrCT!bAɑԏN4yu|`!iT>1)jq+Eہ
ZD,:&yNa~ܺ>P2LQdٕ~О*.n +^aH<4&
3>"o+'
1%#$	B3>14*%+_2.=Mi2//C2`-*1N?_IWœ ^$i'`_\CE?npr_vx!t|~{?_O(/-#Y.jyh"?#B7
ʚrOc" bl%:UƏm"*o6=S-Y32!_|+>Ձԟ!?ك9*_bo	S'8	-1ABL1J		;	)	!	*/ŚĪä̇ƾܴ!ѧҵȮɄֵD9n[g[kZ
{>)7Եghl|,5Si[.npU!<@6Kd(n5Iq!fjQ#[mqZo4Fb?Nj7PjN!Ȓ`*6jjjS
V`mF+Vk-PoyM'Shl4@ف*AILbK`FbVkb;ƦJonh_
~Ҩɿ~<-˫ZO8<-6l
IL"]
ZG'*ʎmd!R)Z3ky
0dYJ|moCOm%<ƛݩp{?uv"xϘg3|AӹMsLUEk1eT;ZAj5HqƢ|5/UPL񮬨æ	zԯ"7|8/Z~>rSU.oPH@|.>LZqZ4ly4X`@SH`㉯炤Bǁ]3c !YV->qE !,(0`b22fpfi Z	m`J.QqW b]EỵGAd". |Aa,r (
H։54pzG*5CEG'ED⑲Y,M~- Z@&n\9NE!dJH311^v|hM#N4=hE7тM9ξm,pN&E`RA6gU%ZɩFu_-dK#@Ӵw=~wes>Nb7ˎ`hOZ^{=CLnCه~%nv~7Mxכն~_znp{
G8%p7ou#qo<Q_YHWsToŹ{9yЁCGz{t'KoӥtG:յ9v@@t!Nqnw}{.}Eo퐏O}'X3y3c}?OЗ~O=W/zWX?˹
s61cO;.?|/']icW챗}qku̓Ofk\5]]Ygx7{qo%~ն~X7
x8m7_;xE&8ub†a-Z/{&,x5:|98=6DHj'7{%xNx{|h{wq$#w%gq}GXhUx\[8pDžAx:_ؗ}@rvFiUy*uz(tWzyȇ\[DSt'f6Hp)~lj牚؉8f6c}Wh	wzGz8؋VvyHvm7)9`Cf2?2?MA1ؘ';<S9N41,
Y$&a)# 6@vNYT졖Mba/c)O
~2qF8pQ	j'S3$#61@}98tZ`3&F'f:9Y9^gaxe3䑦diY:љȲ
РZ	I
yVƹx+Yy%3AQԩ9+y-Qic4Hc5J3{w:m3$C6"% ),@;b>xZ~PhuTkX{Zs[ˇ]Kt_;\hlx},2W44VKI=tzUKF#үY3
,Aq*iiA $#`"Չ$'^_º"NTr+##s6u%H;/Rr&~Ȋ|+}ԋwӇѧ[|ܛȃǎnxQ
S82U{k+o*&M"0K̯,8qp45N٠`/'?)N7&k()s9š~-,16*3(­ay7-1p)aDI_faEaH|FnIF\fKQ|deg*ֆjӭɃ!7#+,k
`jƊA;NyȤ8b,\3Udk
ÌK
;8$)%\'|.R,;\8?
2lîR֒V|Ÿ\Ź|žMLӻt4qy

ʷP-*;=awlH0P9J
hJ,l3V7#PǼ_S?l=X,:)67k95;J.J\-ĩ8aC|ҏz*hq(`'M` ``&X@vh),}M(мD0?zRY1ԯ\yRތ7PIc]Û	 ςpq͐
7,_ց< %IbMpq I8G?G:Լ3:lʂ89
J86m`G`۷}:ů-lv'0-a]-M]-#}JRRG6tSJ檠*U!ϺD""9-}CKRCIUP~ς$Z=(K1It8A CDA]
3gFgt0}ETEӕv4)!2SDp$c|vn gP>I	F I F[RW~'PjQ^d0 \G xz~z{{nہ|~xWFfp7X0eWC:LDIC_TV*
;M
:V ;~ay51 L;V駻aSK)ؠM9b2M5;E
MP4HޭM*PN||MԴ+YzB(&̓pXb
6P?`60]0	Ym>3MaX>m,_u.G 0/52O2o9_0O^vN_n&ogNl!Vff(9Dlh[ϣ\U۹ikhu`fnZ9'6M.uvCM`ooM}E}N#WUoW_25oPhn6Mul¿mgP``>MpY{ L_IeNm??_j_KaX		&F	Ml00uFGaGRGR6ugѬӲԭ0	85	-1ABL1J
H*! AJH_(Hŏ C4'M&D)eC.YQO5	-H"ልlЀ2#YNo׆Jlh7naUqЩk]yɶ۷pʝKݻuܛM2	KxˆV4Z!c啀cufm*YթCkֹjj`%[H$(X80TKw9-hv+ԶLz)^hZЪxA*|Pn*/z@*l/滐ѻC90J?B'0>lNܪT)c`Y3#A`B)	hB-uT@d"
|/+A!9e#lwmNhlsH`7ë@t}kd
[Z5zO!~/Ѝ.(:<Xb|
z@'TO{Ke5֭|jMPa+$jP~v?7_7@!=WNP|$ڗ8?gPFBrPpCߟBA}?<ڑsf'cYsQ!BHs	`P+ڝ{G\dZЅ&
{IAg10fwu";hm$$a[D!V&PVVD>}uQ M$V
M 9e%̣N8
\yn宂A~  ^5—.̕jpz[U!qu$2e$9,}XLfC쇇)b.d"*u0Te&?r2ai>R/|6f(V!D%aW*|؇Y/ѶkNUF>pOmD𙑀f1tAsT_X @R)=z Se*{\#W#G
&Na䠁R䇩VR~㥕fNwP]F?Er.ch*F
@KzT
ӕU*5#!?ҏF)xVLUkڜ*V5Dk\
*f̒,YӺ2ҕp$V*Sb4+y M{]Uj
@ͱMUM"	'-',uQ/0ʏ& PV
r?\f#LaATLV\ҷ˚U_3l%@
vgWWYLGh^A5_.@@a|ޔV2ݯٲ{`]Uf9|ݹ*SO-,wHsUIaؖb~( l801P",N@{-dT4H9Q
hXn10rQwkјGvx>u|3NfbAq "s䄩Hn(ߗ,}.Ќ3Am&gAjlj=lm^F8"J3dWW?wх4jY/z/_zff3やQCR"6)YEF"	EJnbn־|ҙU^% 0OOR0@G?Syw-iT7t*QSRSNXGe`}yq1qCw]l#V^cƙZ֍5=Lw'JKq} C6ctF2h&B{:DQQi&{;]#|@{n?ܸw@j2pW_˛bYwmq.s3܊yv
^s+IޞfUw~{UAڎk;Y^!a|e2lgȈhQqA;ztHvSVVVA6^&}ջHٹ7+yihh͟TS12_GlUs^VrvM	~WgoRaFS4Sd^wzCccn@?l%w{~$7@Lm3BxCm`pXL1%W5ХWqxg}WigW{v؈n+ww=`+et%ȉv9ՇB/zCavG3.3{^#sS{Dp&$ tx,`\KsmAp-PQ-7nԇ002H2PIldV1MJ;k0H5(kN$@!xI"WK
i^9P>g	Ԉ"I$Tyt H8)l#;H1*	s51)i(iH&֒)TKFP'h ]97&Xw'fP7@~3nYUe`'4 z9RVh&+9Yu| {NP	Iv'K
Mp{ٙ|)~Y	#ql	t[!,=!(OQB%ڑy *rɚ9ЃtCrrFy`G%d-LNYRBy:[hddQu AւGAI(Ai!y0&՜١ jlF5Fm#艙
QHà	4J'Q-ABNQDZFJpljmGy$zyTR@@!;*;H$ĉjjlڦ'!Bʜyvzx6|B':y[#'GIq;"TTJuKHQ
H mZj;kʦ:ZzPf:jszZ*#CMꌍ)LGuPG#TGa)HrIIB06p(`G'X (G!zꪣ`-*,M0a,;X9BFg1Px_䳴2V30&
SJ+:PlX	^{eXF9۲y}j		[]W9wἘDap!Eȫ:V2QQH#v䀾6GQG&˾|Q`jU૤P[}~`%+!gxA[G&,;IG9ީ',S>\򵹰K>;:k齪pbavG	qw!AaiqPlPG'{9-Pukn,G62`8rtR q<*+8FX&MgijfU_8MK.8Dg̴M,3$l,MƫK2*kR35\PNDgdSTdʮ4bŴMPtr؀EL+-yݔ˹9.6[GXL0@lhX1)5hU=%?%EX%[,b=Eeavi:HTc?"GUpr0S`]'tֈҹXFKE+eDr
KECU~hhBHy=*{OO
Sm04eq7`cu8a1Ē[":;CJrčmL`?)u?gځl0EMP+=u@S$0_ZyG`cOZaWôafw0qsETx&$c6m:GefY>6b=UN`9bz	w1T:sߙ7upy)4)J@?f}^%bm"
)*ٙ@M'+é۸Ѱ6Aƙ
(J3`H08\AuL-[$Q;Q
AгfmM̕vkcyvoLFi63Vv+Skf:'wcm)ѳ{0=u>/CrwCŊvOXge.zk.jڄ1Gx^o¶f*fsμTM:MEm6sv"S!JIn89FJ~ I`ݻ,\P\>kFW!0_rf1q'r\twqA=rGlw^~np~}ԔH~/cW"wsLCgwGu0~~kV?f\6s&Ggo#Dh(gqB֌,6.M ;	P;M(uF@2 GxÄPef/G2`?0-|CL[j:K>+]/9r2Wy]y3T1#2Vg#/MF߁Ln^~gT(0`nGovTJGꞟGzkv)4" Md{,h a^~sLu<ǎ`Fېa:*GcjkQb			85	-1ABL1J*)	;4	+/!ð!*Λ4ֵќҚʹ*ӿ	!&=^4\X~^ȩ9xa}IYI^>iɒaiU9eC:/\ќ-Yw3"P~ɚ,qg!H5lU.FH8KFgL@pa2(Ɓp	MH8e\4	'h`q0`&00!.N(ipL<5TZX/-F1aIWr!Dba>__ݶ@c3裟<$Y./tK;퇌|ybu<6ꭧ8xa-M肐.My߆"eN:_8_$ʼn8=BD$)M`.H	`[%לp$xD_jfؠbE&F`A	RDAfDu8u)hB[_j_
M$`	k\sZI[l*dR'Ug
*
?
,p	X+"LM)5BԂI஻`"
epX&;LB>ي[_髮/p뭔f:.,H9|X	k;qA\TrB,
BȜn"/>ěk//*+@2{5
K@*5Z~/Mj5O3Vd'Ksͬ]:U9Bp5-jW֞@z`:+QL	~Ѳ?mp+uBYVdN5;=N5ͮvŤRISUoIKZ}|ݫm0#dYLx6-Sն/٘XD:וw7{scS|kk+F;Z'_L7ኃ`CY#W@eN?
=3O9q~S\ oGZU<16ef%=
Ubfy<,foIXP&nmZ@@Іkkζ=lD	JЯ5-L_#B]Xk"X6hV"fid$'s<kmgS4f1ٲVE,i7|:ts`ś~\;[N,]NYjb*C.e"X-;WwI75oH')T,uTxRYN=qc^Nk':\ědJLAF87jR&ko
t0^xpuL+xIlͨgѣe'G_Y.`F~ι#}f;Hx43ΐ'qPҀq%p
5+pPl`<Bw(EI6pX#0{3o%YI6W0X0)n@#EE$'eo~`aQ-	
dÉ	rkq`	.A#!]y@
VbIRk&d"@ Z)@0'~4qev\/à)P~吘&%@7S1AUw_XwՄc8P䖑W̙R5bXNQVىRxh8 #PWT{xL6>m\&wp"%weB4gQҋx+pi.S0oyJ
NIp*8-š_lވ%!l#	q,ѡf3%I!)eC+g'YdvY#WJNPTz`0.ٜE Pz˗vӹ%,xjJ9}LY}l;"I8`|/0PFo
*d3!I!J\&qWډpw
N*^|E&>0W}n&0aixTFy+EX7fW!oF)#[q-Ah	Z1.`q[0BZɇK	i4F]ޜF}i{ߑm[S$RVCGoHg
.`@MLR$õaظ:7li쐸ɇ]8EWdފިx]GE)咞":iǯ?Go^C|sh@FMzaM밌EMeA^lG~M=Ʉ8	EYmmV~_>>m'uj$S"EEfFC8F@IdG>~H~ԈN}V:>Vۦ+X^$UWzGf(';,EMVOߋ3_eKR^DaTM:iw7s0JLHsWւL#8a6wV=.P{Zߒ=Iߘ>ʅ	^tORyyya|eH?M^;xrc-)n6V:I]_	kE5."_8_8I4@6(޵vwO㟍TCWff/#k6fb"z
Gpe~KV.j;B~gM^q_8ޱ
IFG'			85	-1ABL1J!/Ƽ*	_;)	aĉ &	 @Bǚ4t0P	
60jpQB4\AdɌ342.3rtqc-kvI~(ѣ@H9"!3):*uT\%-\M3,+\snխb]޿^…+vƋJ`V)H$h%o@f,_Suϝaj$E={697n6>2	ԩUB@뗼+vlYnʛmdS*
1Wzi?ޚo?d'1TUA`r1'8@`rGĆI)u
<L(ItFel,ҋ.Hl)"Q ?LutFYY]wYUށKa٥3琙&:_%t6He,`T4!A!.ͦm butn-ʤۍڔZo-"l3Rm.u:I	
4a©  IjBM`1Y4˓PJixi:8vW0ACmz	<)(	p-gA~(2nsm/ҧ̷;/+0:{,@j[./wkZ*L/0.<_0/~ 2+'l׽-&bߎK_%￧}1C++?
"-B"
`@IIK |҄	,GI@"mņc z]+MxMDO9#GsHh"Ga:9Ue",?@w4V2B2*͸<{͓+<;k+kv]

p<+hWf#]K_zЧξ3P82}ox)^xZ^7>oe_=q/L}m`'G A,zpG@`!rBb	,E	b%b"!zL~)+ʜ28ÀB0fe
P&ADHGeQΉTDF7	NǣᬦS)1DBS6MP@s$`VԆ\a9HLA+Ɉvdi+L 40p5ӚX%%-1%3eY[OuҲe~|\K7yQSسCqFx>ԡm:e]Ush@1P5MFF$ D3OhD2%%q"u)?
ی~QէP$ 5ShF$j6 
jE	T~`:ec(Q:םJ`j84Tjðg>e,.i۳d;
~he'^>^d155Ќ϶s)ڃ2ʮϝu>ҧvֈ%Jf
RaZw	Cg'lY[p{.Ko*
eSL
bR)$BK&!S=$9$Qo6IpGi$-J\!+FHX{a$hM%5)Nb(X-5w{ہ/P49>xfV&c$~C=q.Ƒ5Gku
19vuCԿuj!vwt!8#BaFpMlmwgJyWZ3
`>Tz']$
g. ɗq1|)hRzU>?tN."|=h:DNEhdӁp4t!@E?fd%Ȅ_-Ue5b(@EnEVh/.3dR>ւ3&lXk1Q ?qp
	0vBG'?a!sf$G pb)HuBu€3HmGxW`tcjC7`d7tcx7m1:Ed-梃C.(43-а=xBRC8
8243b/.PX?.泃p\'/+ܨJs؏-Ď@$u
Ӹ-p@i\pF.KxN@30xn)00 4.2/sPN8E)eqRiW䈠0L6M9xSIX15FGC8Ygq8+Ghkkc
tӖ}7a_8
k :b٘!g[PihpR^*qEBM
Q
IS
u~AR)*1IBf%2¨vt`P3vy"ak~i8
Q#kdnU$iWbٝI
Wyiys&%'d+,g#| qIm"!	(47FM)r)hlxd3k9a$H)QG)QVtb	ٌSYPfƀɞ;ʙ@ژ$K7G#Z
? "RV=i):&b
Aj78ykr_(63g)v`kYCu%$blv4꣈ʘ擣j4AꘓEd+X
?gdp8H[Hsb=QTUj{Gk)9r`runc5V)raJ%BB+	ڭq&b:x)V+M9d aiG7kk
h"_qZvDe(wy`)+7Mpâxape/Jw_:p(&.02˭36~:	k#z)lL!#P
UY*D37IլzfwuC;"u]:)6uQۊ4%"I7I&!R`*s^p%iYr[+k:xz|J6g^
Ia%@_ЉR:+7IrS7	yiUo`ikʹuH7EQMP:Fz&0a`#'
(Hvnj:w۷{ț}
&R(&X
j9]k|7#t
i7᫰q_:vNח^/WNrUwNrj-|56ה үr'YtXʽ!qGjHQ4N(^*hۛOҹvJKKsv Y!
<,&'[[ǨpsMt{A`
&YWLJ9o+6 gs|?~Im"(r87QGl;
6k_	kIgxk`vs2;:0rı#I@0o4S
30ʣIX
ܝz[59hVByɶN+7S!3T/ S4baf©+L)LJu("?!yso[2*mAwp"7
C]PJLJ9H{kPrPʭ]
Z̛$C9<	NZ(x76!ztUkl
[٫vcY!R',
,k"=ZpwIgLSU5\BzQlج+ǠR˫?9Zk[F7]wd׶Zk*##7p>ÊjFcW|X͐cI=]p
e"Ð(1#a9	7ƹ>+Ӯ7wܖj)Hvʵw	a9RiGҼL+ܤmE44&W3}m"25CCm2$5+)/3,1mB;3\0e1ޣmx&ҲVH[=T1%Q`R?H0cUY&CQR--8>JJޕ!G !@clcWnT`HX;}ݦx
*έ0Q蕳aC0ԯC-D@Dh{1- „=mQH%bAcAC1c{aL0F>B$$Cr@4O?$B^^/sdnztoR-<$h@Gvtx,sq~/
+AZXBcn(9эYsl(9#"qȖZkw:+k#jqS2=vȆ
HKiы+,İn5LQD=d:btL`C7 vOuQ 4'7ym1}gQPŤOiRfT}q0hYe0]$h$59ZLߪ43OHNN'?#uptw=pPȑvM0:氘AY~INk*\hn
܌	ְ!M^znzGr>0Z
.+>ˤ\oC]xPv,Z\U_b]R*o
ir4c_r¾p@[)^fAz]mq%cr\oYĬ(O&q܎$
9ex6%R			85	-1ABL1J!ϵ)4/η!Ҷߵӵ4	+;r2Ba]@xnK
:f֑Cof`9u8
&lzdݼ:jL-?:	@>IS@^҄)5dm2©U7NEpʕ7Xw$&	R&F$8H`BC(1LiB	W4I$΄3ʔ)Җ:':
t	ȍ`+wW [w^h80aČ!SQQk#ݣ? unM:r)C;zH
JޟϸU|TI\+1cQS8uLh_6twtB@Ak"zǕCJ]g:҄zq	5PEy't%n]v`rj$-$t&!WҖD&g	[aWZ!T^"F(
oKm̓.0LJؽcx˔PaPiau4Şi8uL	⨝CMl:&ة53) 5VgK~jDSd^"V@2-}najHk⫧NR׮D]]-+)#HpŶ'j(JP:P%'aLf%)ۗqZsf	8#vimJpFq*wis@KN`@3eA8wㄐaXV'6_B=AbوuPLv7:3"'E
G0P8><*	Cx:W8:t8m̬n蜃#vc5XagtnN?Lў97,B[oN[;;SC\&dtߥD9Z2|(&sgp$C%)7*ZeR/K1uo4xP⣂2("#,`W"
h	rS+È0;RyB@(
 ? G#R"nxC*kTڰ25AGȐ4.(suHF,Fyyy`\AXJ1訣3G@j($Hg9L@А4&i	1cn?Fi0%LH?b0OGd5ka<L`g<&P\F%HJ-8IrL:Su(tҕ&pW.cɒJyG+#>ƯDՐ	(&P,ō=T
-+MͧAЍtu`.kbhK
*rЈH`ѠU20Tu4}m`bOJ,+m\椾I0SRi"ʍTM-
[ΰ[O}Nу9ZNYM	RLuP5k
W]l[ώUbX:@1
l׼*k
[XβMQl,n%V˄A1h'sEVfZ?WRfD>*oSdR6)J[Ҙ4N%{(1OV|i_Zsjm^=qI-@gZSĆ[];07T aI#7մMj[^q<-Q&-&7l>G.Ӏ?NLa
2aPNPNڔ]k;8w;m`)C_CwQ ~Y@I~~850"JR,0ن?x]y]n{XttN$+	sҮU:G{*>%#W_dc-rx^p|!er63k33Ŗ(FM0tHxE\<%2yuygNR~a4N.~2<5(Xgzg$34pF $cVv	0{t@{cр'wZgJjEPRRR'3v@;g}#W}'ȃ)h]N1N'M'N{qWc/X*[VOӗz
#>7mr#O%`30L7Fdc_=jS[D	^P}mh0tlxr}#5{35MdFou>u	2GA0ŒBC@zW:S+d88:XXSGQGޱ#Ȏ@c-ҸcŸqDgBBkSFBk`
v
X.LtG(*B5H/.ĐBE0?x0ORffVwЄ!3`c:1Z=pVKL@_DspsDb#p0@|1lFW4t2x%Wz=b  CiHqyI4GmAwp Ppc`t/P,q9XQ{)З0
K`,3—sQQ#əru6h)jɖ▫38	>1,qi@E+B)y<Ӏ:\+$bI~#/i$ϗ(0@wH>>G _G(|noZ[J81w|P@gLkw
k.gAƟgO6Pd&pʖ`.V)='Nj3*xJ*QpFruPu4#"/#GJ:R:E:G
#­xj+,c
a:+9+J630C:SՆu!($e2&%e06g[z/VfjU1@PM 2`_V}ǕŪXz)"TہyoW˜MZeʜ<+Q*b!f3+0H/:\a*g{
quCӹۚY;ۜkzikڷ=Eqn(f{0M(R%wj"zuKss;CZE1;6VHn_:̗
Uh@wY;(mDx;kʬѪ#1Ut""Ѵ»p R8VK;J!5{BZfѽ*b#hZ>b̊[]vT"oꤺ*&T8>E׺Y
 @RjbzfZ@Q@'[d^Vj_Eg7TaUdAh(z2^)S`9Amb+m"toQ9/₼E-DܫU;+:u+i7۝M|q/Q*MɭflyG!Uwd?Ăň@xl(MOcfMf·Fb&Kڹǩ
seeG6@>&ufW
AO%R3z-i-oL=
pDɼS@5u`wkL	'0
VE_jsu3guBr)m
%F g!IJ1 u/W} f0l*2H;INFD#.!M]ߪPIIzH!QGz
SYHϰGJ?I37MD=]Y!^W?xAw'+NfaT?%0N4ɠ
h4|
qap
5_	RүKœCKgUұN>/1Jb %	*kUgJ|}{6XXEN/^S8BD
M`PTF`#nEd`UlG	!->P1!Mꬾ\0$F{1#xxa٩1Zq}Z
a%^B-NHڕNϞNnf>e^N؎e0ilEs%Ub6-/->&mn6fONXPR0N(_R2>"=O7T# mRv@ a!PNU̷^nG߅NIRpnas.}vxv]>@ዚ'=Q';-^$o"?d_YƧ'_ap1'$
ZSX@{H^j
鷗jhIŁX0`'P'0̍wc\}/x/sbo]$
yPԄNR=-R
g$0Z	%1[wf > Ӫ3>ƅq3\t:od*OLH6R%%dGF6FGGRF6M&G&¿åěɟ			85	-1ABL1J
(ڰP͔3uP	JR$p`E	I$@Tɑ)GF"FE\2‥V\r@+2NtX#0%A*d#fyVY
_Xb
m5l۶un\s"OŁ
sW.:l=~aHB>]7pr*3,ΕPl9с-`~rtKlT)!!fcFݼN]$֫tʄh#%_>TTo֞簮꾆
8r!78A]Ȑۿ7}_hGO}D
Xp`#:1[`6XTRb:#s#19i]M8 6QDMPG8 %.htDeAIo-@DI"m$'
[n鈗 \fTjִSo6Qy	x7^6cgVz|}@O 
`Oc5'cM4JXX!.zjΤꎢou]IFhhf4U7k}I3rR+H2ײ递1QYb.2]SugpЉwYzhEΥ
*
_BmjvQʩĚz)*q"48*r`+1
	Ԭ(/VʛAH$hxB9FM`@

d*K4TQuPMٖ>*sRƵS܋ZI墽9_s'{2k8@p>0^5Y|.}ͲJM>
	·1: unX:9 E"[sb$>T+-p=[lTȚ8BVc^$.̴
l6\/8R`4͔fuQM!`dX`A1a`PZN&ԙ<0i9Ha0f;
zf6KTI	>$+J"H37k&Ni 0g3g8ƢEjJL	1[nC,d?!iZZIք
$g=-Ǔa9 y[+D	Ր0<0Eڢ$˞o\]}{0)~
cR!갧40p-6{6
MFY.(=n-K;f-8jrಔulZj4c4zEuKZ7Oqe%݄C\]g?V%a4ZІpyi*Sq܏c[{%	qU(#`[,I|夓İl㭡D	EEN H)ٚQpM-NW'džzi/k2*5V h"4Wϱ3aK1(6{
F;(H3ZDdYFx?&	;llMBSHZ[KK	YϺӋ1ed򐥗,ݼ_@E(hQp@W.P6
`6 4HKA
xlU6k.%+gi
%mn>7X0DBC	
;@C/p"DI^F9[)O$i@tf!!if+tE4
!PuCWU`@
Cwٚ=p IАjTŘSF& !l	)~T'2p14p?	`(Bgw yAӔV'nz	u O2qAz1wJICPPj+/8yNIqvH"4'1	
aw0cfɂd;n
i9"h$yYn8ʋY*KX4Xyd	R@:uIר(8Zv3c{p(QkQ-aPsxp$8b-Ѡ.l!>nc5V(X&haZ9>bӠ^	಄6˂7պa{;L+WX+
cMo*PR3~AƬSpwN!5{Ŋ!A.!JKP頟6V۽g+kJ.X2 JyvfIj|)v#x05soF@и0xcnʹ{<]WW뫭h>Uww0ʣKR1xKK&x9v&GnS̌؋{JL<:nQyR:,qG1knA{"xWlG)>X#*f9K,*#@Q@ `ȾIJT]*VǰՑz¸1%
9ZX0\X\1Ǩ5xb0&
EGl:IOL\MT0L~
0̀f)۔QN3vd!	iw::#XiZJf":3v䢮sqE{'A+oМ*ygܜ- L-M(&wF;u+ʛDq@p/ֲx4=LP1_0n#ˊ
	)[T-̇lZ܊3$֑b^JSf0&+
XfvWs[WoWwJ[Sۂbʿ>N~#̜0p5u+)N}rLu9
k--)]++:
H3؂ZNa'mHݫX>È@&"f'-8HVq_yG<1?)f#ޮE>t2EFشͼ(YGg@=TR'[Sea4F
?ID@
1Yt!k@^A}9IGD1VBMpN	3~B411"	D6n@nSᡠB˶YZҞ&xk`6hjaDRLKmڡ~
ЖnK}Й.$"%+! ATLD5U'{8[$:6eEALC5`.Uew!~OUR)Ap1Q!eRSgVAn1%MzzNQR>~uMg.:R)"R鰮!”ؚ|nNpNS	Ub ؘˌTMbF$dHƽXqDNJ҂&̲܋㛥s޹P=u}>FHvO8gZyRuO`NqYa^.tՄf_	YR2`"Odx-]EyuRR?4?OZ~d!秓ZH]U~Ĕ4ٽqڀBik-`.ؔ"9ɸ.lNbc
_vOdv0=f~&Eߖ6~2njzB+ggfiNђf)hl(iT?pޘ04HsZ)Biqix}ihi=i7=KQ@1NGR%6GRM Fd6			85	-1ABL1J*)!/;	+4c">`S,Dm޹t`?afb8!hdU&`	U࿋)D
K0,CLQ
fsm֩C*˕l3I6cΝ i:,(ՊfeFlk-OkjuU»`jt0#AXPICK5HH"ᒥϞ/I`U,ZJlCR$%i#fW[[!xr¼|$f,Ye͞EVͧpGNgX#kzw.
-~,إTEMPX}CgOx~	TQO9D0j5K6N<0'KXQ&ur^~E5G1g~'ށ*އ՞Cb\4{7%R<84߉k0-%sEL`[m&Ԗ	n$k	s	bDa&j4
tj¨iKsu* AYw3@#
5}^B	UGd!
tmeSW SKF@MMS##0PxZ^x+*Q|64*$;S]lnŋP\	k!v4fKHC¼kWUxg?(+rBv!i68pɝFZh٦hFr1ʹ̓g`G4jaHϕ]djKM6srO]۱
ӘVD"Z^#XrְZJ>/;xE7gNxV$9G0Up7CNg蓏MN{e<0%>/7ù(\eI^qn}yҧԫ4/t\몗&o!,-Shv(S0c2%6`MNɌdڀ2 F(լ
@$cAm4&T!FQ
E]8(!d&&0T2|S
UYUw`YO74jr{cxg
,>QBh9Pk(7@pTܢ'!z8/jMX9FU(+L2P$<$`
AG;>R@EX;cHro#(/rC<ђQ$HxLэ$z0>[DYXGGJҒP40L᪙45Nw-`
HNH՞1@P l`&ɟW%
uT4*- C*7:ѳ& B"Rp@TЀ\j,2MOױ-UHcS+2YoتhiK0!jMX8kH!9insiT84=i֊5Pp$;6Z{&RjJaaXS!nC)PкOqĴN[ZfK%-:*1jQ{]57uD:q8i>GV	tmRXU#Uhg#fų&ifnu"=`h80:b_:YIiL-p'R2I<`-CO͙1?RZt7y<38.l98L$.T!zf8?m3NM)U}̩e0nbbRԨNWjY
lkH놆b9WUL*OQj8Xz-QT+An{ /eAR#*;NovwP*0)g6@DO	[y
4I5xv'bFWm`k*wuBn0gN,_lTѸ%~׎C2ęU*lYEuٝM#k?Z=[r. ɊN=bg=ZLӞ*n	:#F{g.
Bmˆf-fmwgO杆E;W
:'Ags	u8MxH۽7Q@h@tz]X$%z%+	=n@QTV<Y,"k:,$e&8h{'wv5d%(XPW0lhE|/D|Il8dԇ5Hm{bt"A'x2|N	zw>hrtC:Ga&og_XKhRMOhSW_RdJj*˂,8R$y=`h8CgXotyqqWq\wxwh`|b{iH 0	pt1|mdB}g3VTfwEh^w:RZYS8RZu%Ɗj5s?[=|'>sh_3'XqC'p`3	aUIAw4zB%~\guur6#c'wdHj;d_9E_u,%숎V$֎uZ4psCNTB?Sy:xAB
ؕWU@q6xuI##a]gr#Td0vxSj_~A<5T5^jCYe3I75tbUg]7[S6Fqcf…zVbTEuTՌH6\"g`MHQ@~?rHxj!J;
R$X4Y8ƲE/"#94/(7P2<9sR#*tE#\+*
ęA
a5qnR(0_e]
9X^I}::k
7T16fD8b7jhy)6ܓ `HZe7jX(`h+6V6qPd\gj[yE)u|zP	0}	FT/
0"I!HDZ4$@фn˲C_7O4@WѭڣȮ0#IZ8."< rk+;ұK<庰דJB!.1.׃K0qSU{ᨂAgh'g&lȷ	|k'r}E?)wUmyԈ]Xc[~8tiڒ6|vn-RK:+^"@!:!%EC0#rR| !2|۸}뎒 !ҹ	·Q/[";1ʺK$aa#*u.'!wJpexRci%[0\AGz]+䤒'W%]uuwx`kMw'cPك:U;3#388: ¼G4-<85a;쯕?;sũҧ?:=PHKADӂ3MC9I_G|ew!xF6w܅Ȳ6~]Vj'Fc|}PH
x;IŊ R;u^^%/GZF΋~Oxyy=wޔJǁѬҧCM^"ڑESYj~SE"P0O6dxy]|4ufnl~/ڣ%㏅Q0>S5On2_d=s_nz#֡J;ZޅZsq[c)Єa%>e;LWd"RPZ`nW2_Z[_sYj^<y
*@?k)dh{iny;?0h{Mػ`%b	yA( ,y~[N?_x׿%o쓞vp~}(/V.Ɯo_(LIdi7?@O9OOiի^x)ߎekz6@wa)n^Hѣ~			85	-1ABL1JϾӗԘޒ쎙وytKSRj*,hkaH"E<|H+
CIIa♫M%=4[fLw-唹2K}ɍK3ys޿MlDP+WdRq`GZ8Q+cNױ'qM6/Ϧb}6&_P2ۇ1SNr<l&(Sr	g瀘:**>u6`P@Sn߽#Nlbp|9Cͼꟸν0U|,ҚE_ӘJYi^
M-=Z-SBW5.P
uM'F'E\p[u-!lwo!s׈q`0%|Y|WgǞ}Pv&Ra#dhf@؏D2 -`lWIp	/zRbtݛ1bgw,%P:;g
h:h@>9zNxm6)~?vW9p%(YR%V]2HazŪo/zna&kYp5]X0p2-WaW@	K&~fXE;&'	L8nJ"2ֈjit.-Э\	n&k~1G(NjPA%	%X,W2i,GJgl2)Tf
umQUnp'[UBtKu]5pk-r6|cvnp9MK`}\T7mnMq]f'UM/\`>MW^LC)}),uѐ^ PE`_)~JЀ)PLbi{r͝W2[*bƷ|?WysfFEZ†ꂹ	op0&\mf	$_G7Z
bpRm@Oo8`ЄG\˺m!&
205ob3>h:M;]%pM[VXTg0%FGԒB6 SqF%o3NzY}bF1RO"F|E
mq7/'4"­AKUG\`|ZHT)pLD'_i+	 /r9)HGB+]W4RuVSTkB[f:qS.=4r"Q)+Sy=BCaFM6jܫqoo%(VW0;F
nDDҟ8M!Hr9di`qc{3-:MY`;;	ёj4eF?\i1:E!
K@v#HȪ7ԝDQu#*&@FpscV仧Q iaU;u	Dfih_*putxȌuvI|`r8:oŨ^7f;K]H՚E9ߛOE
h$y3Yi#&|ןd6ϘTf2(F2Q5KV5Us	\kIy	0X[V0"UU5eD}"vP]MXB|T&$Y0oTӜ3R[MK*QQoI%gLc/|F9Ajb`EmA<10%DO6Y:NukفQـ#^6ڷ-!Xܘn:ݜͲ¶zNz>lLv6ѫvAΟ!'͋_zMid3LŵlӜiJqR:,2ByDp3Ikt%Ȫp]$)0M25]ЬbX_UP0ɼ׺@lgs-ֳ_wl?RV+``ifذ
Zߵ,[m٦ݹ`2lY<'vߙ
=XıqxKjdqPP)X{@^yJa6,	.p8qOщ;=χaY>O$*=
ES;4M;̙YB4s~kıDO`X퀒pOo`f'w+rG&6)P\&."~NyhH>]5fx'AM%TK֕;ѨOYzLw9ٹCww&_աJ{C"#0%$WYX2sWssrWEHe$r$b32q2aB%#&bw<؀7:<|Tއ<ЧuVj;yt>SuI`tH]SzLW0~f׃b8d8iw5%6zwGixKEGu%bqDb$ㅍW'gwJw}Hr[uzN(Qxu[Xxaւ@8bzxew؊qQcu5E$jXЉ(bG'jWwr+x$N$Q8xaxKutu=Q"{C#MIu\d(_t`5siqL3tҨ{Ȋ9vy%}j9rI M`07}G0rE8=gX6H~c0XGpR'jLxL' *v,B*qirf*f' ɉ™:j*Jg#bo8 @:jě|iSZxK(h|G#)@9wFp9a|؂C(x#h\ɦ)y[HjXYz>WYMbba#*Qw:*i#
yH
v*X&(H%9Ȩ?	 z~*#Y ПbF0!9O7ͧNHkn|iaPJʡxy:(0#~JuNH%ٙPȤL%
&tJ>9رH9F>7Hi-KSɯuX=ҖijK})&LF[J[v
'PZq!#Y>z#
%JХiw3	Ysw;KqXLRSh		C+aGppq&8MqL+v[53Pr5q`%	CKkCl{nZ}ћzأuآI~AK;[JK֫V۵'	iyLC4TU1k!D4ÛZq
Yey,ˋ#!
sx⡢;̔BQI%[sa	D*N,WFk6p+V/ Y,d+` +n,%,nA0ODþ+B$+r|x&Z|vTW
YJJz3*r3'POhT>p IY-)}NOp^B<ɴex^"+2g?KcC͸0Rek_wt4izJpXZ砨OPi Ћ$6ѧ0|{ 0Qk ;;t睧tMpĨ{RHtrϮth'4,LmrZNcClսy5"-lBk:_emKKɛ(p~Yy7z _2 7iPbŦ|}rppjz8\e;&C#tO8mXV29K%pq!QNLg/+徝4=^3pHsIpnKb-*UO(	pH){޴J:	MN%HiZDؙ̚I
[?In˾80Ɠ'q_d4^c..dXE74 \6RZ^QFLFΕ>i1RJ4>N:ХO@GCJWRcb+.DU&y8kPq"Zo_&G,_N'	PٳIy.ƈw
ꑾY.
>_7o%א[{j
@a̧ᇣQ8o^
a
#۠Rhyn	gYMvJҵ> ǝ>
-"-F@+'E~,٬NvPc.q&./?VqVc4,uPP_@TA&_&ddÑzE4-,R	>>Z0Zޕ5-҇]O  GRXFI	GI&& #X'
F	FMôX I#հ׸ʼΊI			S'8	-1ABL1J	H`Hb`5څ$b$ịDv(3Y-vlGãSDx2o|܈$HwxrLGwi&	VPQRC^5T$؇w*
b*X%Y)UtW6E+ew[Zm1*_E"A:y,4[gټ	Sn.Y6"$[t$A1J&	aD(C~][7nܲaמ
B3g&N(:e~aɣVٮI ah3m)@2|h_.$$9|NAcωÏ?⋩uBDJX-%R
iW6M[ɈaA
)SZ7啓VFFZZ;>iPV
Ց\dPlZdB)HR	ESuDBA	F4	ԞjUU*qcCp)QdR͘PNg&UQ	[nf%M"	.19.~KVlB#wkmk#R<&5ỗ8*(H$&`ru	,'f,Xp#F`v`'4-:!Z2"w0#T(O?DͳFNs΄FScc.6tAjVNLljJDo=479}:	 U`!$*MK:KUd-=3CMSYGGRxt@sH!)Pً[	H-6ΪLw%5qr6/ۈ3frtk2켕ȃ%l"Ɋ!(a	t&#Ǟ0((Ȭ	-`V͌E6C03sG8⷏4Kyۛ)M0S4wI$Qf0
5Xr%>${۠ENgl@\LB^'`;@L!L\%$TAHM[5 $4J9'NEZ5@NzIׇNji	CDȦ-9"ҥ	|XUòzYyi<,!]U|D02
)B}MlwċvDN,h`"W<ga$.6+`妒EBrl*Y΁
m`t1IrDH%Ɍ*wGN@pkL6RE.VQ ,=@PS/g=U3|`"GϑtM!HѢG) bHaj$6)22=O:
t2P1Yi;WӚhs޲ɌDZ
<`ʫ9KicVr5*ixbFIU-݄íu`|Z煉rƒuUkmමmk lc٘m!(KV'%)XG˴Xg9סǐi!ʕ9+K+|d8qXF7M.Rd\ 7tBp{EȔJS\Y(5
>M'[LBЈN5-IhhISF?˺Ⱥqo_̑kR&u&d+aSSVcM;.v5nA6HOҗ>A1L't6P/P:խ\cܭ8l?ݯz&^W}m]ΐI]>6N.ձ$Y}z|u/zfwio۬vQ=~udw8Yz~-.=^O~bOy^ϯsA.x~د
Hm ֆɉwTk֐CnvWƐ7xfYw9qrͣG5IgM"XUoKU.z9Xu(!t"/8֗G3yt)ǔHx-dJ~FIp;x~'yˆn'`:ըw,gc$ydtڡ ":$Z&z(*,ڢ.02:4Z6z8:<ڣ>@B
uHJLڤNP5RZVzXZ\ڥ^`b:dZfTzjP\R:~6tZ{Fxz|ڧ~tJZzڨ:Z:wz~Jꩂ*jZzڪ::ꧤzZZzȚ*:
|ګ}~&ںjzMKM,p,g纯*;[{
:8jJ|j}ܺޚ&?Pq[2yiP,i P١ i


>JqTJL۴N{
MPV{M@g*[ .gKڱx, F[0#y#P)??0зrj;.[:+"t21~Vqp|fBRQ۹: i@	P	zXJce[;˻gi S)pK2#yʶS>t7{1HxB
,#$4gFK}vt[{{JX[e`	 |[+{Қgi t[x
{0["2& ;P&}@+
zZ³䪧p?`
~FiQ@[,@a}z\^dL
g~
Pzt/#	"K*ۼ?5 0{iKZ/<`'g>{I<\FO|Ik~ooOƴ\˶<`|z
HjL&D[Ϥ\
з۸oܝgÚތdݾi n$mq<{XPC
ۻ{g,js˧80\ß]i
Zy{M~yjʌ݅ۺ=\,>s}A;
n
~p|ָA
k2]2Z\^VnY8@6-tJ,ms(z& üήJ{M@w,ϸH;w:opI{-{o:p""{4͢>̩&?U{:N.}F~]ܔ~ѻsJpU~~n*N^͞DgF^~>^~?_
_[@@?_@ "?$_&(*,.02?4_68:<-B?D_FHJLNPR?T_VXZ\^`b?d_fK/ lnpr?t_vxz|~?_O;PK,~FoFPK&AOEBPS/img/ccapp017.gif1GIF89as}@@@fyyy???ߵ??3;;;```>>>sss<<<ppprrr000PPPvvvLLL   ϥ߲ؐr&&&䔔OO?,,,ooo//&gggXXX___󯯌OOOJJJ///:::ooY__L666777lllƚ999uuuėiii444555ɉmmm888


ttt'''˜MMMSSSUUUQQQwwwBBBZZZ~~~hhh---ddd(((***}}}HHHxxxDDDqqq222^^^VVVbbb+++NNNGGG!,s}	H*\ȰÇ#JHŋ3jȱǏ C*P@	
30a "cʜI͛8R`00Jr*]ʴӧKY	ALE
ׯ`e5RX֌طpʝD>2\ n
LL(X,+ьmL6q'(HLix]5PmIGMM>5X6l+_|@0X5bPȀxg,ӫ_Ͼ˗$
_@_,_z@E@5$-)8߄q\
ֵTl4sq=Yt|X@C587fI%U_%g@y&А%'bExd%@U=qGL(&e3&J-H;7KI#iXQ%g|'oQai	T}
P0I	~Nb˔j2GtꪬJérZ
@%ɂH_3򉕓-AU"i62̶v뭷Bq*O%ʑIN9!2dׁ>[g
*Dj7.LtkvTl,/ۣTЁR~ْgr|SG0
\ū˰HdA?G-u20an'%5aH4S-0	'hn6C]cmwDHiQ-8-,#7޲ڄ
 v> q~
y[1/?Ca.qCAUl~,W%\_~^	۪ 
ʌ q#BY@WLϳ{_=o+@YP
ME>Юgf~v&%@gjt{ݶ\UGX`# 3J%6A,A#
#8A~R@d (| sD5mKu22T<$*!LbOe4`nȰ"*T'VCR 4 c@\js":@4PQHd!*Rb؋ԥ/،]eS`0$*;=BaM\
J)҈-m-(Xt0!"pILKn!}"ŔT)kEz%T+pqre9@!|!B&y\ `b%(+B%b=,PN\BP^uRU|
H.	h8ԅg"5%ICcDEaZn9nKTKV,k2	wSfvXj^S2!4UTAB6Ummt3f8-\g?/yfehHor׫زU@ <\Ǻz
0q3핊#AJĮD$W!̅Ѐb~u`$ mY᎘ٖFp +&D[Wu#4De_$,D\ -(`ʋj9\>T<17.'bj͊0W2qs>,@;s@\o{7/|ěAqc<B?->v OIo\S!Ucz3iA
e
G?e AO}VPwv
Ƹ(:Ѕ.íOO[LGAoΌc{;?"*8?tH{`X$@cf?eV&qbV(y#o>QL2Fw_%3ZzTG+2'IL1p @]]՛viN |O:JF)&ب9J:޺Ȭ:z<`7P7PV^Xnf;أJmf`; (G	ZJː`U)0$~KKa\0 :hZ`J9P7P8Bdb,x3f:̀ PbB?P[?khZq(˽1_!Ak+f:ˠK[@@`;+kܷ˝7Yk^ISRCA{*F9˾[C)||\˛9{
:Ͷx{7@J9LlvJ3lW3K@P3@X}ͧϓA~~ڽ,͸|F|@@ma!ɥ9@Yk*ʳx7  [*@tKZեi°[ẉ浶,M?V=O=;YPDp<ęMkˆ(:Z]çLǜ6	ѢɳOoқ]K\F{˄uA\Ӫeۀ]wk*CY9ݼ;@PփօœĜN!Vy[Nًm
Upk٘=؛
2mM.SJiQ՜m*oq[ŋZ=򻿥g..2mw{+ʭ=oGBk@FV pcWmԟ/̧:=<5A-̈́]|I^Kn~wڦ|LaG=Lt>$.&(>.uFv|~NNϠ׾QJq꾻>߽Ţ<<Ȩm
9!MyA6}|r.r9d̸N߷H{
\P "?$_&sp-@yx}+2Q8:O4p)o_6oLNPR?T_m)?GI_Kod_fh^w]lcvx_X1âsu߅ߑ[_kmi@O؁ka1\	\<@F]oO6
;Ol_m_500$X '	JC%B@35nG!E$YI)U	bٓ
>@v"ӧO&,X@A*,SQLE`UYnzWaŎ%[G\̬ysE;vӗD"UtF,FfԨB#Eis{ QUfeϦ]vvli8pƌaÆ*C6)ѤK+2D"Ed`B0Rh2eʚ=beH:N(0 IPJ¶+K\QLˌ@4oK&OPCuԎ"MJް#P
J1-M20[$_dWRb)NhTdUv
#6w8ZpQ-=KYsH6iĄ!)8vYz뵗 #	>PXrDEGZe\С]bXcC,>add4LT0xnHjI6QCP".X#dv14`1W!KUff!d8lfS6*I:"U{o5H;Y$D}V[4"O	CœU 4boKc
su7a5cO
K@nxM7#tq]t

yA
;PKֽPK&AOEBPS/img/ccapp015.gif
&GIF89ae			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~,e	H*\ȰÇ#JHŋ3jȱǏ Cɓ(MB$˗0cʜI͛I܉;@
JQWK<pzիXj	&%PٳhӖ
{OHbOUKݻx1'HqKRÈ+^̸ǐ#KLroy3kJ\SӨS^ͺuϛc)qGŻNȓ+_=`hg\7wĮv'(D]\Ӹ? p*M<b!9h>80B}k$(H:J16RY$)(GmSRC@x7:Hs|Y܅:RuX&?A 	팋Cb:$3
%gǙfg6.e+kOwL/xB 
EvK<%?q
-e組!tՊb˟Mif0CJh!W=Id6Wg
s
.0xb.Tc(/Z~$'P򕮝f	5HLϔo.AM40RѕNAѐ2;IA2Ԥ%l'bT)-z2*MT%MVZ~3W5jVպՑU$KHXߊFVEV	2ӄ  G
X<;Y	[Uuka;"؎0v]\р,f5RY\vXձxADڋv#-QH9^
-xQMr:ЍtK_Inu+ަmpSDHY,wׂWgyK_ײ]oV[ԫܝ6
"
0'LNpU3آpGL\X#pM84MWA8αw@L Lu}i*|?*[XnK⑥x-sK;oY|ݵ̤(wwOYq$+Tom}Ϊ$ώ9i
tg?|KѭrG=E7O~|$^p]i}V'Ճ鄧]et۽KuQ|t]tiz;>	<[ϼgGB[D
^>7Y=[~ţ8_bD>}NA
+o<]>w{^ҟ~wq4W=~ϗ?ĽQgǟ}??~gz(~AM@tv-Tx`41N
[Ckq:P0lCn"Qv(XHW$#~6AM>MoM+b*8QhWG3!߰'KXЃϰ'/"(e*0тH
s:TSv@!h.e<'0o41"N{,y(N1A4B0@1>QF7o:kGWXQH
at#h?TH.!)O.f8!b6ӆ@/Ucm:G `PGVte䊤.v; BVf(\8^x/ Vh>qCil
cT^02BTȌps?!ݴhh.W&`8@/(
@?Ds30䑱(WlcNT639/2R>N}ѐэP(;_#0}惔D|QÏ D"I2<&ZDT?oSc?{$Q!LYǓ ᓘ?lMQh+J30pp1'hh5r8 ҊVSc5^YJ$ BK+mb4v8
xoW•ED&7`/Y1&D2;(T9/5y҅ywY" YAZY[S!O	p9i~ٞwYՉ칟~e:[oJs
ܲ֠vzL:o١џ9$Jz*٢0&rjڡ7Zp(
;j=
9-EZJHqR:3hOaE\ڥ^_:d:9Xrvj*&%EAhtz(vrNpʦ&~"{z˱1Bn:"OH		HZ[{IƵ1H H0"MhCsH!EQ+9xF*ɷ1a!hH4	3"yfFVEɲ+V4{ю/r;O7BkAS!;,_h@-˸ 35k_7#>bQr Y;7{hȻ2!99b50)DA_RXD/ŽX;;)v˳@DLDS  hY,581:Jky[t94!?;w+k;|lM*bH5ؘ!JpK+,A?c7.*$M[C,"N#N£ho[1?AZL038W5廂X`5<6Ṿ gy?r}eLK|{,d.|ōb\xUɑlj}^	5ʇ\},[J{tɌh*2˾ʵ%̲\yʼ\2Wź|;ԌwͼqVs\2˻ժkQrbܓ̧φj{|L̮*Иϕ:|+К
-+]qџ]!ў$}L!M
GBW.r33wz-A=!"@GFW%\2t&Q=}fDFJmr{d5Pa}[=_7-{	"OQPbvo]
#=c;҅R*$'r#jmO-i-&oU)(GbU}"VC]ڦ}ڨڪڬt;g=ۺۼ۾=]}]!0l%VbM`'
]=b׭pmviכ-`-Ku}]^흟F=i)Qms~"}j?xpB	D\5^~^]%E<޴&*kcdp>ib('$Iw؍~D~&5!4'zaӉ%wp`ݩANoBޡG%?NN4sUA]-zQ;5QoS`Z2)Qu38E` ?@]Мzk5`q6lĦiNok=Y4#cHsY1V7UIH~٘.1mJ	74Nkm'!9]0BkS%> 9f,ַsq0㹵4.>Yt%dS;51SR)<(+#|ؔ9oư3	48MJM38M)E	Jf.|s2N{AQ҆b5πKuzc/hP;3J34ZԶP"Cڗ/51?/"T))8)?*X?G8Me0im{!.T쨅1>SbxY|1K*Gx=/9#3kx:."x`Q?|~8#_0
ڲZ€1NƐp4p0√;r7t_1КOY?|?ZFT"v2AH'JRirK"A۝/o@K0f`2ܬ17YZ$XA#P"!r @~	|d_@^LrJ(cF'"ILXb*5QQNZUYnEW%[,٧E}U6*Kf/=\_k0ܦiO\e̕Yg%#\2aip*kؕ/mܹu{U떴WL>^uda?ď,qO#7\.G.|g-m#*3
*B
+ck9KtNMTqȰ
CChDAX&G /{%!,NF|/H(B(w>"Êƃp+s@B#s5YSPCuTRK5TTSUuUV[uOy1IkձCuQ;y5LNvXb5XdUvYfS[WE/Mt=_Yn[peGi˅ZlSӷ]xw^h5UP]Izx`%_wI~_-xb+3vŎvm[*X[-6dxeւC,DΖ  B0dg{gzh6hVziɰe/{.	,`HE6lV{mɆ6j2"P N9|p7p+0wq#7+oWܻW$-8r[HW
zh3b<]7oz&+J^8#Q7|{~WZ`rY?NeL0?,N<_XNF)Ȝ&mDZ_x2Y锵rq;f.mixpzEuH&B|˨,'0o&E|c<8v 4I}.[%y]Ht&y3rƵ(b'~VezeIcLLEPK;dŔ%^7t4]PT,'TOMAU0MOӫYiTvH$åBy:8;^T&e+GOgU%HPvNW
o
,b{,W
f^4D5g=Iǐ_lF7Aԏ
E]JHNt$ZVYe"GD -*P E(H5%$o*OL`[L:y5#@+	 *Hƒ!nuki~qD8֣|䯴v7ĿEpAʮыpqD1*,}*YE|!
Fq⃰il|cX;q}c 9u
"%Bfrd(G4k$'mAp\$oZsq|/$[&stf+awsslQ7'gyvY7z0HH=	yJc8CɁHΰs˺XI/CGYPGvv\xb1c<+
*t4cƄH6,ö <OK$04ϼ"*B|Ƀ`rڛyg23JZ̀LB̿<Ť
J=<1؃z<MŸǫCěλʒ̉ʐK4K\q3x!C&(NEZ-Gp<'
 ;>p@+

剬8PP-p:8>X*_14Fe	@;:dQ	@8SִEiCI]3/
6R+6U/b9N@D	=yD¼R&8R	LP$;S7x&ZS;-At;4ԹdDtTcTRὄњCLT#U4ETP
v4-/UYZ][\UD_%`]^5cdeufE6ThnVoVp
({V)6cT3w}WxWyWzW{W|WٌXT#cXX-زWMX;PKd*&
&PK&AOEBPS/img/petgist1b.gifGIF89a@J甜ү-k֜s(jS*sZyMWfiۑޔkk8BJZ{ZBJRnRjmB笓bk1Wkέｭsz`sk͜9΅(2BXsr,ksRƗvZk{{kΚtPBsqtRл!)ks{đtΦb!3b֭֜{R$RB{)R!)9NO@ZP. JUԥdſN1{!)!cBssZǜ)0̓Y5!Xs9)RRs1!,@U+:###&U>GG&U:˘iG*\ȰÇ#J|Wڳh2"pA$t,rGG>RD˗0cʜI͛8sɳϟ@
JѣH\ʴӧPJJիXjʵkS,U>HF# IcXdf^Kݻx˷߿LÈ+^̸ǐ#KX#]uBԖ#D.ӨS^ͺװc˞M}|Ho}-wȓ+_μУK>Dسk}	ֻk?
,LgϿ(h&6F(VhQq	Lta0ŔxUH~"Xb1'_
@h
>,|eYYF)TViXf\v%PAbjh٢HchXŞ|B9)=nE $|I\jGҗVj饘f馜v)'@ffYx*ک } *(WVO^6F+rb	׾j20뎻k6kJ6Z,H,,p3xƹI'	Ȱ9h
[& !"k62(,<`åb0|I^v%N+zث_=rq
@DD-5APnve5],dmv0q3}z'u@c(D2@2T@@
a.2dlp驯~.[]wjvĜ8߆gc?&Dlnj/\P@
ws/ꪳ^?w3cN.nj;c@e,P8|T8	Hq[ڰ9'@@9L5B@;`F؁>$8~cabPwBD#b,#6x=KF
Ya}BZ`x̣Ȭ$n[r;"Ȱn<E]:S^%nqL p2x@
Ω
+pGf'tPcw
 KX~vl^lA0C"	=l8YG4
D(j2k܀íOۉxj(Kp';~0"ӘD*6𙄴[xeEL%R6n0
%H`RYsdNy'tZP{/Ӟ~TBtc&T*"qN%1J-lq]T	o
0iT
1\D;U9te0;Zh/R{݊VMl!Tah2̤"MN3'Q^1搆Ee2%BWUkd_A	Cxp#Z
ݠv03^uW+:_5f(#G8BT f7HwU-ElD[x%JW
`]Wёy,=b>"y\%v'Ҳ-0WPT;Ws59J-=}_	0R-oI-:U<0.K)0n6O?=AQBqNjH	D%H
	
2%`#`tNu1<piөKla/Ԩf2L(3v;g0Xe2"gΑ\-rcnh7\N%i	V,*2GԨ$xh&R6;tD_bu6$RJޜHUoF)Q}s?I]zeb5C`+`xm0:	.)nC"~ݙwZÛķw@mp%r'xI]m!f{HS/+ӓO-l|Xxrpz5xXu7upR:O;ONhЈɯ	Qďj@)*nzzNm)fi+;kĀ3S\<8{_2[Ͼxy1wZ`v2w 0{.K`ol,	ڻٽܽٓj=u;<+bM}B{ޣ%޹N`;<٥|_]֜eSܟ+݅;ܮʒ[1	@㋚	ύ0T
㢋{̓ŌZM捺!{ik{:X>d^jn}rNkv~s|Jinjy~j|_芎ޠ^9}>^ަ	Nҩ^DZ~븞^n9P~ډʾ>^~؞ھ>^~n!>^~^0o.?oNl/ߣO?J$_&F*O/'2/pFaF8*+O-?!?3_FoF F5 7O5F Aߧ
ZM=#=_^"*M8lnpr?t_vxz|~?_ozS=[Y SOUZPY_*R0OAF<
ϡ/5?V_"?_ǟڃ`q_ڿ޿?D/@W ?>_R`9RDR5DRRAF5R̉F֙R१#&,-H&GRR
@A']k 
,@B"D_L.R JHbFjF͛8sɳfDEYG	-„O
CUt7=R`IK	O~b]q%[tvI#gA5l7jA6.e2VMӨS^ͺװc˞M۸s]n]|lY+^ilNe2U={j'^D2k؊D
P/t5!=Ɋ ~l{}2f `(2EEfv ($h(,0h2(P68YA<7M6(&tNN
55cTu|䕷c"E
DA]
Q$~dAiJe%xk~fpYaLd衈&袌6裐F*餔Vj饘f馜v*i
Wv*%
HALQ`*
t&PŮfk3e}xUxeY*B-SD@З	_L0hDN@
#&"F^=Q'oHZhoڨ"> '7A	sXH$6Fj%c).L<Q\X/f""QԠ
H9Jr`?,ODD%"X65FaBRtV5--?3Zp0(H3ݏ.Z[H[SF@< {ծ^G
vt5c9G8t!HLA':W,"1X8mjDv:$a_P=P@9Hv@"n!5BQvT3C.wf-V$,oHcn
>kȾ7Z)p:oO'ׅW8)mqFw87.r#4C7*/KGs\o8-Nrwގ[Ʀ+9`	5FkéVgHՏŰ;P )mk;aKyR+&ٗ6eKq_H0}'}M;)HL \}wq'|GV.#\^Ϝy=x13qw9qg.~}8k<grp֗<rKucGaPuJa7vadi@%P32g'>&> 
)cSwd@wEw!Cr3@&R$%l6x,m
!Lע2ozgGjc%< hm0=I0rٛ'}{s:vhU(g霌v.G|rg:	(WmzH
rA:VPW!Jb]Ih6b+a]"֋	&-I
FiZYt*seiEiG	:z[vM7uSIHjX&cɁ(>$j
;0/&Jxc>JXAƍR&llygNTE5nx vxa=FN큘h	^2J]e\.A@JqUqm@I6g@@(|FA(׻χ5:6QZk堍
Ž<ރѓRfѶv{HaS)j¶0L Cg]ki	l|)s=xm):،؎ْؐ=ٔ-1nt'ٜٞٞS|LcYTJX?vJZՊRkQnGJNl0Q2D
^4&Aլܭ)n`ڽ=]}Mޡ(}NrHԈbIȪc0mn\	
nc3-D1ҖF[mʛJA8MK6.02>4^6!m(79^ګJȇ9S)>.d]֣QL=*.2Wn'`b>d^f~hjlap)Ke]vc.4='^t^?~芾>wnyޓbl\馎)}ꪾ갾^cY.B^2F]~Ȟʾ>^흝np䧚~	B^^w.ّa?_3?_lRPc"_&(*,$_*4_68:o/'?;B?D_F=1]QGR?T_VoJo(3Pb?d_fI1

M#.2$(zo)z,Bpbng^
+aۀc0x!NP))(
(!J/
(\!]@!_x}(!J(o(϶(ˏr2B)ů(?)!o))(NJ(	$#&,-H&GFF<BҦջ+z($]X)G^*hu8ʓHOSdLu6=L#;2G*{#D%fQ㺗dlI*~8fȝtꎨ<&I
I
FsdѲKW&^
cB	xhliSf#֭)H`4zrHg*nfR`Z%\	
Ti'+B&G)h5yj9_ 
,^"(rN@'
|	h@P:aciF	rjN:+cf
p,k(y&+=㈦fTD*
g!XbW֣D`L\x3ࠇT \>
F;_#L8	0
s-l7pܢ
%0<
P 0
4)B#U@o2ǰmF0:Dm9)XuϾy|%/{cq:3 F[+(BifJLw;1ZYWUtQ4v٬H+؈$V0k<?1P[H-$HMF!DAA_T@naB!(	^}+ D"M>@=x%,l,^fXx"XVh3`0BWQT	+FU.'I0	A|~h$6IL>_8 1yi
e:dyG"ԐU(FزW%ݣ8p(tf痸3&%IJVS13E	B- TIL_ޒ$pfqf3$D@{"rA51qQۊfO63(
x[aP	@ m%
~*ք)6]~z2bZ=w=H}Lvș
&Meg.]b@\R8u/(XB_cC4hhC'#^I'
aBH2TJ|T[
1UA$o2.qX]Ռ۫@	XW|BdWYЎ+îQ-cXyn`а^^UVFx,Z&n
mCԑۃ:Te@j ,}pՎEڞUEyyMhiˡLQdx2T"UH Ub7En@+J+bQ\_ظL߽l~׷
P*)|TiU6XE*xn|*Ra0:}q|Hٓ]A,\:ŕϲ4l1/LGՄ]A/*7Ta8cF|[.E[E4ҐҤ3_M߽ JӖt.-Ra1sMiOYI‚,]=Z2a
l`zS~]lN&1k"Yp]8mdK>&ݘ<۬&ܦZsu@E,
[A7-9C&O],4$@qul[6v[Ƒ?jϫ"ɖ>
3ŃМJQQak]>B
9mM$ˢu[ҕ@S;|w]>/D~mN@=}1~W߁*Q3"|>e*BC8YyCACXbϝn:|؎{E`+B,>Χ}l*}Rݯ)5eO;:5+RaYKVG-6px4{%
HzXWҵ#EzIB~&%R瀊Di@&mW~u.[~p/Hi"qk55Uӆw&X)؃
HYo#v)4m% Fc4&Ȅ!{rZ^2	hXTexz|؇n~8XȄuXn(fІJ'$s؃엉؉~&8X/e航x!Sia8xvȊ؋ur%@%،8Xaٳ}8h8Sj1؎8Xx؏9Yy
ِj9Yyّ "9$Y&y(*,ْ.0294Y6y8I!<ٓ>@B9DYFyHJLٔNPR9TYVyXZ\ٕ^X)Ub	;	fyhjlٖnpr9tٖPx1teQ~9Yyp{9YyY
Y9Yy	I9Yyٚ`	9Yy)	
蕜9Yٚɗi9AٙbhΩ=乞ٞɘc	yoɛɟ:Zj)ڠ:	ٗC`2u!8@Y":$zw)ڝ@0R!,"08%:<:)U,j8ʓ*
ByEڣNP?>Aʓ=GJQ`zyI?@@١pjӤb|ڧɘI-JGʦGx~:9YХ*,*zJz:)
ڤW
.ک2P1Pګ艩.ʓp@`:ʚq*Ίʺ4::*ϺJ8PZZZzCZ!JZ W*۰<æ+Kp*0

$[&"',۲Y֊h4[&j:ʳ@3+F{JL۴|R;N
*JX!jZ۵^۠\b;d{h+0kipft[9vzx~ٷ;[y۸kkm{[{{
룞K#;/31;;;[븻ۻ[+ߊڱr*jʼgIgY
LFi>	zFٽ5ڻ˙{**`ދjz*Kkʦ+UCB	˓C2@y7K˓˖5
	<KU]틖160=?Ax
=Y{D˶J˔K. i!ֻoDE
ڪbř
kK\LZYz_ݓ}ݣݼ]լ ׽}b}υiT1rڨڤl:”Z:M "0+Za#N%>MGܼ:-ݿ03p	/Ύ0r^n=YDn[6Γ\ k`,5N5,k nL-쨒=t.;2?~PJm0
<7>~E*'}źYb,%N̢.. Y-]>ƚ+׻,J ]nU,޽wn6|ۆ>_Nm[:ԽM>53O}.>r/J>n

;^Թw.X>e֜NAĢ874^'Jӡ< -OM?}=Mn=k̼:顼O.UzјwRo#lmޥs~߬m#Ԅ@mEů![N*@yж!u?Ig=ons=_qo?9w%3
62/*(8	"*!%
/%%0ʷĹǟڥԞÎͶZ"82
5ifV6L3qX8
DCITV5x-%,8cErV#sɳ'8PJ(#Lhđ;%f
Ri;I(
x9QTJGh5k}.1Wɝ"`(:T+x]U	/۽4^WSvm,]5/Eqd^㹦Y3jwЭD͵U.bt
S%N	
[Nil#9Zn[f7)M寖W5,EThG%TSOETm|wD%5莂rYKവ"8hS](c
ME3Pe_W-vU`8	4'!hnZ$flnĕ[ñ7+8c䶁?A|$Hf0% &[j*Jo.	lUap
cHxVʕ`3Ih(iHf~SRL9pt*긢FB&SR8PwjX22nב:,6kA*TaݓDHx`+Dx#FB
L"xG*K\$'IJZdGQ(GIRUxV򕰌,g	TГd.w^r*#	bL2}"L\Y*ziㇲK▹Ekr3Tc6BoZ2;Y3E63DβQ#N&	ϱM amәp72>kU>r \7'U%
 8<2Y)#'
=zڠ$>h{2a8}5gd2xe_m1$Vvh~
([T.D*lxWZ1^AUQAA0XNx6EH&(zE/!p7Y0/e&ch׈{x8xp@q0A({/(q#Є4h
U8p)茩gy18TtraWt|o~MEW.iGOZ(gs,5;hF
'ؐVkю}7d!(-(okGMW8KR  ~捻7yyƗ^g
>Єʑ?AuCX~rt2)1wb3%#JS(U(*„Hۇ")X)k30`#Aj㲓b#I%7'.H2Ғ$Öty-\D#MU'0f8(WQIbG9wb}F/iv
Di61'%k-~ޕh41C4b4o2,vÌR2WUp~E$ 5!+
Fys{fh,*wb1"-|A-)vfGbP&U/dx49:IW:.#s0?Sk{
8c-S4=s%RY,'3
j}D10aJz0ṢEoCjے0]RmȆitAP$?9C@^1sg+7w6&7D7 3<7waxH~P6#3}D3?$Q:
ctXx-/@
Ӈ	@
@!@L@u
:+q=jqZ:6j6**d?=c2;:蚤ATFٚ>}-qFZJWDu!kYUCC}D0]gKJQ-E!fjE۱(C#C]B߷FەF+'Khh@;kCs`,iꆷD~N*YdHaXBTZDVD[;d[fka{jl۶nr;tkIp[xz]t|Kt+FGZCt7-U5SD"$v@G8ZĹq䷌ڵuz"m깛e.Q?eldYB5VcǤUjC4R=!td{IG;n*Bk
k5[eC+""d[DD5[5WD6%B+[E+TFGp(|gVSkDCkz!Ue$p7Ľ^S۽X%af&l_#D[>ab94dJECE(%m~_4IG "L@>sc>W_3gf2_%gA>aPc#em5y*{Ew}wxϵֿ]Օ\Ĵ[k:OTɈbذ`X	c8y2
H[k%C9h'Szݯ|i{z/*	Q tSa8Yȓ
]_!x̓$
ĪM})ZX~}^ܝf@BH{ȒQ*
@G91ᚁ|3JiԑUZΜ@M$H$hiиgleGAnؙxN)Ee5*uܙF~nIR۬#8~V$I3>OUNՂ12I=b 8w 6%	]=~80gb2Ώ;񃿭[j>{GP`+yMǞtn"qWД̘I䟞ț)c<[F$Y7yvo	&;كՙju璙ۆA݀2;=9v\"	ƍ9߿.a=tBzc419t#{Oɤh>VY
LJ>9?b*Ƥ0O5RfC*/t;j}9*}N~[-'
4:.`O&9jb

62.*(Z"*N	%43+3/¿Ɍͼ8¥NJ	4"ꡜηПƲݨ@ݽ~
앀 wa*@A6C+{TV>"TqPǘLb毑vʬ8"Jx.ρI)=kxNGƄUOvK,;<
Е׾ۀ`†gOx_a_ng{[on'Tt6 e$ڂf_xv ($Hޅi^o&0(4"w*X<@ߍ}!B&L6dDn+>iXf'a_9r)WY9vIhe&jwN'it\2VUdp6)Q7%b5J>Jh)Yq)2X2Q0MHezRcG˭#Ug%xKS
l.zz:F*cRa"ifHJ_|!2.d %gNۘ*W$Ȗ!9 [	U
GjX~;Ð1^KgiY1f\Ԯ
Z.{*0wy0i
(sJvʨSF
pl$8-Um%BNF`xpVk
pDpDV20SHz_u8Bkuui95:%0Zw!{/i3q31)h<؀%5&U
ۀY@2e"/0Tq[TYGe\hIB(vuQ`8H`{PL?(k@3Ȇr:XG,VG0!*dŃQK؇@
aC#7 ,q
Z9sQ 0Q_	 ;E
1@އ!h@xR q=,CBB Cd5p=~A(rZZs!sA3?KV乧n}~.CÏ
#>ʒSǵS
Ί^S9,?yCT;<Ɋ;ZpJF<>p%Ms
?ezD	EmPP$GDKGF}DkbJJEdYMtLHI!;E0FLEP㶯K"kPieWeG(ME5EDEF1+TF3P/WP(+4BfXfWEJhkIo4EP={VˀNV6D^maVGTH!GZVJǵBj~meYwA\Z5rFK^5G-ubNVǹs`*V%Z`	4掊Uy`)tW"%dwMֺz[9u¶NKrA6N;oVQ)hռM%#
Y5{,pd/Y#ilZ1cJ|~wg=àcG+#z&aJӻzW
3vLao:LH>(8F)+ÜucEXbL`$|~.|dGdZ1\7(%
hv,EqԴC.̖i=((&'n2)
ZYhkHڑ#4`aHv!:*cXDĊB2jCjZx\;y{"枈r1^B^F;>\`=Nގ,cxo~R9iɐ=eQoM9¡&“܀ΙBC܆<ݮn"SYJtX9ia$s9ﮙ,m	
2[zA½3l	)	#G6pyO$_& "o(0D.:#.&P**$ebo%}?o? ^hojoԨQ}A]i~O$F<.3
,1&-8z'd/!C, 4?oLo[+`X{/]H@0	BI/).j3{? 6
>!-0qBQ(R+#&,-H&G3.8/
4	"%V*N
62ĖŏɎэΗ*!ȍݙϮ۶2H&LZ0
Z` 'LYN{*P0*{pMG+
lrX%$bKSN\LiSKSEPT^:qbEarPIjI#Zt)4kJV/ZfׁpN5Q\qoPQ#.K[T`NzQbf఑:{oq'QMs	29+m8X.G
F4QvSVmj*,|deɸQmm3h\K%k+gn_?:hQ&:҂,4!!͢/)vL4H'`QJE(	b D,	7n&i2/:N~%/
c6gȏ?7>rzP(cלch{GN}OO{7oO[ϾdFOJ>?ϿUC2%L

s
w'x~Mg8&E'
	] 
"t+x%i7\6&U-
t!K&yfT18
vxCA?H P7WAwtSxYdqDPt%c0T_mxu]@yG(zmxuc\9BDTDx>
WJz0;pV[b@>؃^Lj^{8v4xx8|r
{k
x^P^yPՉn's:أ%(u@.ZCxzxsvv@%lQ(i57&J@c!(!׈n'sod1?pk'K]m=qD8d
i 4QDBDGԎQxxÏ.&wġ/I*E!E&j.FKVox8y=oQ&slGAe!%'hTԸb&y
P;~$ h3"+(r#4lcB/hq@+(
OT"E*"Wbe)(uŒNE"c
YV(I(gDѲTAS
ƒ9)ji$b(cb+(:R\i6$J)P
HrM71)yy=oB+v''	A)2!)-,"}y~;UVe3r#SCnY0b6rH1S3<89
P4ukTz	TMsP %T-vƚGO+Xb&%g؛-و=~J9O2q(
y
9ʬmϴ;{7ۥm~m۝wڨ-ڦĽgܨ
}؝ڍ	eL=䭁@@lz=]}>^~
靦(pp ">$^&~(*,.02>4^6~8:)^~
BέF~JNPR>T^V~XZ\^`b>d^f~h\JϫRrq:܊͵A<+!j>^~舞芾LmC^E޼+[>^~ꨞꪾc钞ڕq~]|
>^~no^>
nM-I~|ھbwN}>^~~txnܹ
s[{뙞֎ "?$>NҮ^4_68$n~~JLN>ݔ^N,O^O^`k~_^s}̾pr?t_vxz|~?_kݔW^?
+/?_?_ȟʿЯl؟ڿ?_?/#&,-H&G˗״ɫڟÞő޾:HPM|%4A
F@@XLt1D(P >{0cʜI6붉Jˀ4!P
@(D(z!`MQmQxHn&g)̓߿)xW=ĄPrq(.!uRLQrd"Dd0B(4-m)<|%Bȶlv/B,
KNz`eر1)h3G/@8hyB0~勢\@A-QCqZAAZIZkd@ &uA<<\ys!Gv,`7(& 09(zDQje{G	_O>yZn5,In5%oX$!cא&<@ PE+J!LJ0Т&7	5.Γ" 惗Hؘ7{YXRšlB
MrB@G&Gm/á(LD!|4I)PΚa%JJ5^y0
&rIr*! p!thDzړ؜Z>yy>IЂht/ʘEk8PZ4jMq:lӨS^ͺȞM5 }ٹM[T	eVУKN띆.;ܹ{=<?+QaR˟OϿ(h&6Fx l5`	fa1v!G@
PXn 8b2889>5 UPsHL6PF)TViX@
4tY`hŘda1G1#[ve`)'
(
(x_!$F\(YF*餔Vj饘f
4	snxD	oZ8*ej"lЀ%ꧠhh|ydKq6F+Xja9fg`¬i-pjn.#
"豏2,rmz-[ao~.88l(,2cW-73цx'
M(40_H@2DTS]TgM*1v-AhpM	,&`<[:I.I@ٽ@gxA4I0+ƒ+Y !>p;ro39q16sQz|~!@x(*6##klP(	d@G7A[PP$6d39Hlp؝Zg
(pLGH-y[pf=_eidd',}[_$1H (Gd ]qxgȦlc;JkH12"P;w_KH:Q`/T!Ig׳lioz5$@9|泀%	!	M@NjMZǕ+hآPyȊc}8Tjap%&N6%/2w4
V%9}K@8P!
* #b2Bi6SBA7
n<(m&ʈ63BEcD
JiKgnTQL[9sx6(5JԢ>ɚ䣇Ȱur!g@٨_$}`9M}Tۗ|3@*t
D{RgnB2Zכbƣ	iF*P($0&2 MX2bѩa;Lg~03jW!Ub59e+=5Qf9exuJmx6dbŤW9	]AЀ9k)h|vJ-t6v(ʓb0yy*%ୀ	`0"((#|e7`ޟE`k'L
G
9?ršrOgxrGB=asq.puuٕk[adb-)is&7e`HML-
0#Ke4&RNlZԞ$bT7iBI5ng[CyS!%5d]nvjq6pl|)2^t~pE2t=$(TdF)\\D|ص)aZȃfrfJ!^V`6r 68nSIL&i 1nEb'^+L6j uƙdn9`A.W0#Ź]$.mwes̐2v(WgryaanFT(z0J>L: }szw[Lc<ǟ3pNG(Co)#p6mL{)=oR,R=51
9&x';'\b>9eI"ʜM0rv6h
|*c9/R)ץϽn8;iN껬sһ
Mc;nHt#=q_r3J:9<旯ƗmW8s4z,\b4Y5}37H{puAg;N6RRcb0|&bW:wj{oLug怾`}8+vnW&woq=a~b?TwCXS(N>.`I:@9Viisc`y)(J;Ue4zR;9YgkS@1{H}aJTtA:dǀpuzDW|SM8m8}:x-
bfn>T\YV7b]0
:PPQv0:q		P;	|H	96Cp@:@`8H@Pjݨ
H
#$[!QsEpdQW|rA	H|IY
*!2-0&w|=a!
2لWl2IN,(bUJp% ,V),Fp`^֑n@Yw`sAV2Sh9{SSЏHt!
@cg	!^e	G9<zqi-i/Y}5陵=w~EH>d(%wI^72#}RID”N'phE@Pr0&0d 60IS)	uE^f`zi_c6		
@:$Y٦uȑ^96wPi繙Zz`~!A[К*)ww TX4#BiZM酒 7	\	$pn;JԕY	?l /BJ?WYt9	=X9`'rkv^6hnuhkjmzZvzx	
!
B@çs]G2kH.(@/Z	p?	x0o`ĩ詏0pZЩ l:o
ڇʇph䪎 l:o
*yZzAҠHw)JCW:ID8v[MI툩𫔀J@Dګڈڇ:j	ڬzK
		KȊJʺگ;z(J+}ʡԲ~Ss$#,T:qzڔ/*JL,+NMGP/{蚳y4H(@+{jl۶npr;t+ML"L\7[y3Ƿ}ٵSv0`Du;[{۹"i3M|	G {3}[W8Pg۫;[{;Peк_S˼+=P!0W9_A[;[{{5eP\Z#˼
D'-B}|וѽ$_l~u-;^>7N瀎͆>^.p-`Nj^>dc$Pэ)Mچnܓ-?1.r}~E^v^pyN΋宍sVҍ#<>¾㥎dQㄞڶ>j
x-8>6ͬN9~?<>M~|٪ɍD>2anx _u4 EjުM4.x]t.Mtp>L$S-ڲIb>mnݜq~4@F.M3PR^1nn]7އaـM)~}؄-|#V__fA^nqo}$nNP/Z^not.^6tt-ξ0$c^ڿDPnnfrQOO
^YE$g^3D#Aw#dD4KTYDKKQrr?rY4^C0.UJ.G	ûK^ɪ7M
	 1*Vuxk9E9…,KUYbj.HepH`Û.~ >3 :vКMF/]$Y̛fXMUVFG3<62yźKݻx˷/ʝKnYEi3
`b|?h#>GN
H4AJKy	k4nCsM]?-$Ѐ{Y]~€;׃&>~,U}d^"F|gfޯ(88:jѳVlՇR	'4Dyj9txN4@+Dс>t`z%3[uCWJV=e@̘aM<LT݆`UlC4v\t-o}!BjPQx"iI!%#4hx|"	 3rrْ!
e>|-Jg	ɑD>A#y&[~JI@I%*-J\vkNlr1Q4+d꥙nJe*JJKj+䖻̟.-baqJ.c!j*OXQ4cқI*rAgEB,1*s-*1TR&Ԫd?NZrAȁʨrxzZȴtaq^/ˊAP	tc
ئO)I[1Xg\{
H$.m>cg!H1l IBL"IF<$ JZ̤&7Nz(GIRL*WV򕰌,gIZT%D0]$2f:OƼEgZ̦6^&s8'\&IvV@C
l`3ԉM(9YwnDʅ4mP؀@GMRԨNuN;=HZӯg
kZz\Bquv/jJ#[sЖm_-f"!Zym;h_;F93:J;QhG=f;>
g0">Zlkt9>UM[ϸ-npEq'9^\0?gyez簉mlH&&Qhݫ~V2Ɗ`@7Q6`AR@f?
6_"0[ֻдݵC0m]C
HO;񐏼'OK<xPb@\~TFoe{6}^k/NO" fAu^`^DSyM_WU>y}羈W?̀_ϿCfvwgFvWr̠sUOYdu`F}}'[0g؁!c`[i{O|_g6&E,z074h4~C}DG4C~#+؂L48L5{D@V`o/WAC}Q0Xfxhjlnpr8tXvxxz|؇ti'XF/POw%lO1`NvcUT`hcEW{`t5A0V vtkw[肐@]@uTWu}gEQ/P]P(TG4xu[W\DD׊	~X^tc8Xx蘎긎옆u8cThcWu,UYen `'fwED{5V^{Ogv%>{J6ppK
iiUڮLZIڶlq8O/
sWqLdp$S-
R4
@L)pz]Fȱ+@iXS3I+Ik^hi[D'𳷪Q+pVIK֊?[Gyi&+hmE6\Z_{y@he:^z;ZZiۥK[{Q;[ۊLSJ%z+|˘t@Uԯ@N:o10+(Ze7{j`9Eǟ5Žx	[X|)f6e5B'lhƶzLػNxN3[Dc\]5iuڴkUBk}{K椃{Ǯ|}&%<*5duLՊs٭l;l;kl)%ɧ<NZs
|ʸʢ\²< ,(n
l5%I6DX൳hQ[EΈۡmχb-鼸LN$bc6c^N4|z`hV҇]}٨~	E*m~~Lpl,/ߪ|Rh>|XM`=M~m7Xa
?,06-CW+.<`?Du>F	R^~^N),*^l=!9n.~'s?k{tSnlj_Ws̸:tJcPT~,L4ZFyZ+@U{AЗ[͍/ݹ._DkN捧'`D`/XA?>C/Xwhf?uQ\`aMOYD
Y7p3)/
6	1
¿Ƶøȴãӭؽ/	X	X*FL	 $IsKiNj*¬Bj3~z*6tٴ){n2z
7*g;0 cB=aDtO1XhQHɸH(ӶӿL(J	3])eXlGfS[5$S]Q֓eZ(\d^&'q^g|fY&3kc
2oh21lOr|N:7h?TP 4ьQ:fJg3d]vʪpǍtm7xS;mjc:`@.vF@
`)Da7n{hCعI
@3ՕW'$WAa$ 8&O9@,]3M۔Ԩ3š"u.\6[J?\<@s=^o6_p9*h;
:vӟ m
F>b!!&Dw]$#K>Q܋#"]
y/6`)ZX<mlRD(JóbxsL):RN5P TŜzjS8C8_$>Ԕ6@m~<"*ow+ha<&gIq!L&PvgXRD(*B<)3CLx}5+HG<X|9¸o%/{A2	(AR/Q=(r.L:vn%zs1ħ.i$~Fr)w\XcH$xLSl逘0fh#(Y2.c4
0ZK]T{cuGC*l.}iLg؅sp`{RԦ:P
2&jtJ: ]ˊTbIe	ΔuEiAOPfƞ
`U|MXBVD#JҚMJzlgKR6j=Ce(5C>×Ylq!Bd&DfJds|O=89M	wڸEvE=ͯ~LNdK[o'L
[ΰ7&61ԋttM.L@;\)j`Ww=D]|bglz33iL*[Xβ`Ǭa?")Hٵ!*<Yu2
4{dq/lKREdGxѐ'MJ[Ҙδ7N{ӠGMR/䓦NuStDUl2AAFkZduD	RX{x3O
ENT8ЎMj[ζn{MrmV;E60"o͹wfkǓuY
N;'N[}ͧ[ug\CRh^.gN8sxfA.&W5XP
C[XϺַ{`NhOpO
tnLxϻ.rI_i٨~`I;񐏼'O[ϼ7{GO{32gOϽwO{Y`;ЏO[Ͼ{WZO?-N~Z,(~Pi؀Dk0@Җxr
( "8$XGOrƁqqh284X6xBF)8Xm.88DXFxÃhw	wQ'pB80PlN@rU]QHxOZ~a(6uWEh腧#8dž7K(+P46l	vXCb` ]q3hSH(	[X'-prT@tu"Ѕ	h](2h7@Hi&ȊP]880.)XOHx89xjx:ѸgNp븊Thx؈Ɉ&+/!J~l.SK\h8Yh1 
IxHiU ڸBpQV!)$" Hؒ
)
ɐ8X"!Y3ibxByF5)tHEyFKٔ蓏Ay-0XQ'%I/숖F<^(kI-0Џ'	3cBY) ksp[* igi!I`*)Q鑰وNx9҅LyPhPNyF9Yɖ9ɕVIĹ1i)9mlYؐˉiiɞlIg㷃p
0/%'P	+4.]Q`bb(9.Y(Z0ӎBxiT`,0Šuɗ9 i*.+8jEzyxx1@aXZJ6#0:I/+DG8Uڥ3</Xwdȥ0zQPa.QN:/W?z9nqJQ-Pꨐa`8zi AJhB!zJʢz:_xY$z
権Z~z㩐JHAw
pJ
կګ=+w.肎Mcd<‰+Ϝ
橎ܯ9M:`NlE^*[ARpE-5n N
Ğ޷7,c[}c].N ;پ.Mه0
<(TSW	0aXUjZɺF'ͻKnЮ6l#}nu;B@:vZ@荮ҭ/CNQoo\}VJO8"o6_] J,\I7vE079?A.nʏIׯ_/W߯婯w
a
h7:EEQr$rI:%#C::#		:Iʃ-ɰծձY70.8J.GMM,V(XBPM@90	i;U#6mKIrpQ
VⰎmhfUbR e.	YҡR]!4#2
@j@*qYXpJ .P7:EVhbWP=zXtW[#zeVG	:6c;h"2U	pgQ|R5m6NjV햊;LoQ?.M`4~(Hl",6ƞu?$$m~~
;l:XeəuxrՒLۯf
KfL11ﭽ[6K甊<ܓ #HHD E(ᄤA.hTm0R0_,r~neH*޶,pS&$1O8I0f	}#^2'a$Gˆ5ƸKXh2YL"	qI$8?VeFM1,	$
S6X)
dzoear025-؟:F]1IbzJ^J"":TfgKyuߔc8,I@Ekveq
H=ءLHam覫9YcֺKn+#Ph+
.Ͳ mgP!"g ,2:\(*0ʂqjL8[r<=,t;笰<C4qPG-TWmX}40/t-dmhIp=@tmx|߀.n'7G.Wn剿|w砇.褗n騧ꬷ.n/k'7G/Wogw/o觯o'L:
(
Z̠7zp~GH(L
0gHV6̡w DÀH"HLb
q&:P'(DjMX̢1`HF~1yH6pH:x̣> IBL"F:cΈHZ̤&7Nz(GIRqUGLV򕰌,gIZD%T	=\0Ib~eVf:Ќ4Ig*s6nz'ilL:v|;Iz&(	4:&
@25li4D'*Qx/LF
P&F@QҲJWҖnӢhIPD6&"#fZ̲5uPJԢt#P=ț}eX޴FͪVK"Up\j$S9Ԥo:H8p'TGӠOQNY}FZyAsX8:x92]-jRǘkF}nzрtjUPVYSu-mলMKծ~vfyitݾ5nO'{~#^po|;8v޶u~i7{jhKٽk{%xЄ-G:mIQ>
8{p~9o@QE>sXq
Y˼FzUu{]l{4MoMqX=8.DWtJWӖjli\YMq}	VO	m{`5j#g}Foy6UWLO\ށ浺׸߱soWO#7?uIz,`fZ^;t~noqK渳Yﱷ)]77zGs\Ш?zj>o!t8Xw
؀x8xXlݵKeW n$XFje*,؂O.284X6҃<؃>@B8DXFxHJL؄NPTXVxXZXЅ^`bYf˃jCl>Ќsd
	Z>$[xY(HӍ9>3hRÌ(=

I>8dxYx?H]"i?38(=@3(Yc[PHTx8$/ٖO9	҈<И?9RRi"ɥgpJ.zkkӝ\'
y舲=۬}?Mzz+٬NJFJjV؅cJ[㙙Tp:蛥,پxxu:<3˽3|D){ћ*UX{C:@Կ>Ë̑^(!88:?LNPRm>iΓ$]pΓ+H
>Fk=vFY<[F]ݔUecI.ME]l<[S]Xv=Q<}͈"i$CՉm=F֐<-׿x3eUC#Ue=>5))a-tMّ^Ԗ<0jZvi4Zۢ-F(
_خ<,kܙÕv`ݨV`j4Tjp[a-k]Mn$ߍl
ܘ3kDc=A->Գj4Gn5ji;nZTFjf~`:cm<8~a1^͓-Gsz	i
߾=
݆]D1SYSC<[]r~ֶIm.[z^܃D^
,ݤze䪽6<'ϵxF/CN'md#_кΕURѳB];F&^=>"/
*jl]R?G>.ҨP/^[͓uN=nu>儭օ^>.*R_=_ʭڦ_B?=<\9HГ2/ޥ_zﳬO<^mTxO=D+%oXUdA2Dvb>vZƱʽ0.8J.Gԝv~ڴj9eȞz
i	ں_)I$0%ekءOl-k3l言ʞ,ceIkAa[ӧPJJիXΫw/>H0Dz$ǀ>"Xփ2T-αUޓDZp6Zt3bYx%k`%[lZYCMӨSj>cJ9I
?/e{ow3˝jn[.SdͥT$J+vfp/)l˟O}sϿ(h8v6F(ᄩ%fvᇦY$h(b"0(4zb8<>)Di$9@L6I>)TVieQ^\v;Y~)defl&)tix|矀*蠄j衈&袌6裐F*餔Vj饘'oħ*ꨤjꩥꪬ꫰*무j뭸뮼zk&lz)D+Vkfkv+k覫+m<믹l'7{/WlO[p ,$lH0,LrƜڅx:.<쳻vD2Җ@IN4,tTJaeِJa
XWmKZQ=t0m[N''LIb/<ۈzmeYQ~Fd
e9TyAShE*Br<WIEDm'9?9HuZ]k}u|V(TD#HUZ	U2xNίVKw8Pî֡_(f׷]EWOC@UCjI!aJYt'=?V҂gJP!ܕc/eI~ϣ%mڅkn4ëiyk.s Vؠ`ֲoY袗Z/&npu-U*4*o|/˺!enJc`VNHn!jQ	m&(EVi%K
Q5_؈\v'b_&x7gb^X7x{طBy6k=Q\r2=RAA8٧\nweRK}MWVO\MAJΡvmvo\z->kH6f9ckpfD8g[ZSbLpں/G鏿ۿ7HXx
h
8X~~H؁ ȁ"#׷wЂ.02848,X8:<؃>@B8DXFxHJL؄KxNR8TXV)y5W\`b8dXfxh=j؆nbCluxz|؇~Hw8|(/m؆H؈O(XVhn'
p@>Љ.(:<@=xCH1ȊxIH1Xh0<`Fp((ȍh"0"J0ڂwEqً!И(&YhZzȤ)0H:XH\JYY<0hzb:Ϛؐ5gJڪXٚ)
ع*)#mڂ ʖ4/ Y 5XH)؜)zuĘ芰*ʩ!KY	tY/ڳ>٥OﺊHe70Z
NYM`0QUIUZ̸Nfʡ8\
ȩd	-XPKxjJi +v<0
`ڤnGnzȧ&˗뱠A:D@I,HZHɊy1ʨ{b*HۺLiϊxX٫HYڰi;ު˗iy˽"숡;	b:Yꫫ0XvP˸=82X#j1!銢ܕJ"D(ɜ+Kk+IA:(F|UE;pӻ;خͫؼ#Ś*kYh+]QA`Y( 0+܋v8Zn)V:0Ȇ.ۧ= L'ܫyɳ/*5̸X{(IļBPYܟ	yZ}+9Qˬ_|Qy
ilYLl~|Ł-!	kξ*,P˥-]ʸelo鋭2L`˦-I!&}>)̼JNZѩ9gk׬Ѭ^+8L|ޜѸiΥ	7ʷp
AmL7W;yНR*
	-ѓݞrmyK$שֲlt-vҊʼ-X*Ӄ+{˪n==،ͅH}گHy7I.xȚh==<(k!+4m$L݃zІ]=Nв:Ͻ
*,H#`nBő[<
LcۻjIMݪ3MKȊ*	]fɋ+Zj=lj6î㬫LZzLݻC9n;<^~@ M9Ό~,ܴd\̫yݨ\;EGާI~3+LmW>_HB	]FpTZoqNͣݍm>~~n;辉Z,Fpᔾm}=T7^oY"ɥZ=;7,]ܺKHh-чICd^{26舐.E?]jn{o˵/N]Hwy
szkiƉV
	%͹04ꦺr/AO.#ى)]ɏ͑N0{/0?I*cޫNKv^;_-
]o˾F
9ٮ};<
eNX}ȔOO=#uj|mݣȋo??M{?V\ۅ	""70.8J.G
DýʋҌՊܗߚŁE
~!\ȰÇ#2T(ŋ8`SBIɓ(S˗0cʜI͛8sɳϟ@
zhѣH*]2#3HqaUXjʵk^ÊGO>;۷pc+]DeK>wL-ˆc 'Lw/k޷ScT#fLӋF^Mst@[ѪGrRǃ)N8Z!a8NrlwޫqfM<:TFQÈCj "< bC%Ҟ}U0@$H	"؁H|`C_""kPZ_8G~]a@2]u s3b#"9xA׍]	K	^5d1Ȟ{@J'm8wH*a8|f_2Y"n>"lU[tD,7d*:h"xvn^#t"BKK^䨤RzS
}@(lHyglާ*$*3BJ	_Aڦi袴]5JBAw)-jdȩ&J"Œ{}1:w}&lJ&ďCks^Pˈ"bkju(,вh#=~+ޡHn[
xƥs?Wt=Kis@;u˭p/b_)BcP\%s峅fKt`\q}?
0 !ƕV;F9	Rhv)B +2G[0ޏ۽RŶ+~[hKdwLϳq:zI`[u6zgKLVW;t}-/h[Bv]07нxەA4	b@	B4`;c'vW:V0Ё
B͂D	BӐdX)4M`
CLgG^){əъ~ģEջh+gCD 1&:+"\hFI姹e-`fM c}NpǢ 
 B2tXIBc˓*9)"&9cTDV؈*Kfgkn-vh(F;E4ծ>ZDx	ji4t
h&>;Q1Y_9v=!
]	ǁ)Rx8z
g
"+(`D DrC	#
4Qra!эiJG-SvKs[Ϡ꣐HmƖ.$7LEh7=iQ"9<'>BjI8˧<2|VuX73?֯UPU>541QՒZh03c26@=FVyRހ򦧕֮Oؚ*;PG4xD$SIQki ܱYrjBUyW4NGGZ*ЎsНLYuVQV`>Gg:AFc?x,JX+"uȯ`q
^Vj,@nH"XnxSs5JT[	eO+m F*5
	'WF)].ۡFv.];OY٦U@	;[y$PlJK9E4Omk,Ctmz8T/u_bH)ش
 lvB퉈j[.5mfo[b8UC֠\,8`1'm(}=R%h'a	l6镒Z![;^+gdk8#r9l3TH29>=(We>P	j?\FH7]_\=-'AUß5R)5Yg:_95Lq3=)@zCbpu,V[zIu)Y.]S5Ro͗^|vusoWwp}^7`K^wkB8<(qDXgk1%)~2:cBG02eNy,yR`8L3*xd
٥+2@ GnhhceJWr@Wd-	4Y%_RX6P8Z0'.%!FV8G
8
0x`
Pf_xmh
Ҹ8nьT6؍8XHEq긎8[(]HhXPxlŘ؈V1
 YrYHk 9S!47#Lh{5!FBՁm	/imH>=Y1H?	%]fd҉0#,RWB'ekReHv R!c!25.6MKA
24aFp.W-Ё0G1),XG%_iDjw#68):jkr3p@_&rm)>)B(C'`.7Q\CAh~()O>γA0uSuX2lbY9i#O&9?f+Ia^Ib,B7-R\YYءb*f%ЉhAiX
I
DiX)Y	j\r/fYjX͙vY00YYp'I,ƚp8EAf	9&wb2C 	5#9*>
n5p̕#nzy0IRE`:x8}S^34X
<9'&tWykj:s!v|9hȏZs)|3ZrMp]:I_<#$v(W{"uZ{%2Fr(3#)ut+	N15E1+{ۇ<+	-2rFL1KbӳN`6NMCXZ|lzwF[{>;;#;3Yl}4A48y}"@ԷABz"@9BRBpBB!Fd	C3xZL&C@{B0	vHu	-$
uY7#u#2\=>Jg.Dbp)ځEEj|H$#W{vF(B^eb絤Ļ#ktNVhd\d|(&m`GrVjEOZ]U9uZl-ˇu0Žo
O4r{v4wdHHwTw:+xI#_D:d%eeeR'K%Y;KK!j`TtQW$ΑgYچB"f$떧-	&2FAƿx-dÇ$NEڜ;ltߦ`m*5Vv波Tv%<\տL)Ew+mރLBܧ(WO_"oWpHʃ|xGJ7
Uq=xNQ0&m$}ڒ,=NM+"o-Z]Ӵr]+L}>MW%+CMFEjG-'̟x~%լ_MX';]DlI`꤫ЗJpypp--j%ND(xVڈI<[ss[.߯EOPk~ʣFirFp[)W^]8̝7EݰNq	9MXm}(_MCacޫffik(m~hDP@Nd3cSp;w=ɨSz~ʗ-TC#.:zprbMXT{)+n'	]+U}=
/5Z:/һM}?&A6d9weԻMPRNq-嶖^_srtl&\CKs,gnF2TtPaDMř͠("6׆͜=Z,BbǠL-(r[SmŃ,*qt\IT.2!}){q^W5I"o}*b}G<}W~Op}q˿j9V6շeoaNE`BsKWEz=MQD<#%m4L8"';F\	&B)?Ίv\m|6eZE.Ș~sQ.odru/u|Er.Zļno`);"`t?G	mF=!jVQ_tv샴x_?틷w`6xP
;(("("77<Фg+轻m!|#o.@fںiK7!56BNEiL}5)p0dT7,6s"M%,JGj&e,J(GIa17ę_;I69͕bdJA3PK,#J6QU@ggϗ6+[F>{nud	NRʕ(גzlQfMvM۰M/x6mOCY7rF2%nZ;]ht|sI3XwZyzř3

R}	n@pSDRWT	ow\\%A*#\S68Q@O3\@H$7.b%.&OUlQUc_8rFI$A89(MC_^Zr)}h3ÝhY=] =Z3ىiLrgpk(Lj)kFbmr2|\rh9F
7:xS1L&6,?:+Vkfv}RK榋,D;m+/jlw+޼Ԣo@Vqlc׬	;
Wo."p:k+ [o2x|B!0,!/,<:+j>YDK;/%{W,)3(YTWmD6njՊ=`-v3bmhLl6nI0|߀_w	ܸG.䔫xSx/u2.褗n騧n9.n/o'9/
:Ngw^|o~͝_ް/[|}ȯw7!%6
LX0Z !<(R2W$ire
A0@Q!yƤ2ۓӊQW"cRÙQSm&* Z>#D 92g>F$D!4UY#x°MBH$:STϴB[t`%"Di3bmR7/*EäcA?fHC,q c,cA&$ḮI2F^$ XQd@'))c&S	+)rGPf<Ad&Q*% h6#VRb"Fq(iY͊Z4^S6'q`o{	OT2q72yPLɱO
Zz1L
fm#oHD-=a71HP`"85X">]OV"ыM)H}s\i)JI)ZXȮKb	ؤ)71M,IkWƋ
oVMLT5g:J^ǞR#FCٹ
VQfL;CSMBc4+-G~ȗCr"GVk#ީ7">@H Q[6B]f\Q3mj"nWq"&s&4#g䡩3U~U֖~+)Yr6-`h"&TƒƵZOuA]Fk-&&ЌUCHm` @*n*:l"G<Ϗ4BIYxŀ͜tev_,F
t΀
UdvZ	j$fWA)$gnSt)"6(SYi.}ˇćĀ7*B	ހzD탧J!u7$8:U&ɳF*#W(ҦVreUDdyId)GG5?Lgrؙ#k̡v(C6[p5hgt;ҷLa=
	fbC1$9сT+R{BXo1,uM*4e=e擳Lu"樭mH7ۮd%s<ݝaxբN{"q	cȩnE.an8$(a!3$qR5乼.8^&j@cv@n7^UJLٳړ({~ c#b+u*tyB9NIZ7ޒ.xC[<7S`VBy..M$'Xx?aټy_%bf,st{$wr@1\Hf"Pv%#p
F'?a(kmRߕ}0x17gPEUlD	
r*VmF(Y(*u7&7[7Kse"~>W{8b?ud{cbt6
4\v\PŇ" 3xxȃwxZR8N'ff@cyFg=GZxY(X	H	_$
	MIv
z m	b'td
v0p|]P|0`Au+D2feweHC%чX鸈GfbF_ĉ6 *YfLx1XҐ`6X)eTEk'G@1i(Y*y]#WՌ'%lbo22U5#8:X&pV DiY?2H(e^SY(fA)Bg)rBfFe_4+1]Y盝7suNsyCBVSX]SFМT6D4ʉy!S3So6%-#X(xـ=y90y3B4OIbYI7i6pٟ6o:a4.jҠ79"5*١":C
z>c=*ڢ.02:3>4z8:^bi@&󃢕DDJjK9FʡM:/(T@4cWڥƥ^z0O,-!p1j+jFӘ%HVvN{ 1Hdv-t'GlyvMIRTmJWNoR=Jbd\#GmȪ¦;auق.ŧ-l*'!Jc4t,Rx5H준oK.(jM*/0B{Hz\#|4Ċ9jYMĕ!Ũd-E
K	N9.(Y D)Pm(/S0e.k*/"9˚ZQf
#5ǰKJمE0ӝ"{)Y7[G";TJA,'ubG[5wRkhQU5'A'!
$:9sdxO&{sPx;|xj[jr
V-ҍ/	P#.ȈZvWʚW:xRJY'YVź( YYhZfAӈZZalc*[ɘbt[_kHD|!i\,E
å`![pr[Ԑd[RGyc0!8#8v؈daOO1#5;Iَ%ŬE[K!_Itl+VgKix`aaQuvмҢck[*VPd[;)ѽz}1Bn{[P|d˿mas2j2=3=;mMUt_5´ 4„\_ÞAlYa-`ç0Õ\Þ!o˫ṣę,&Vb8LhGdX&H.K9kz7. H7m
fX]˶\k`%ۿBjyI>[\f50疮(o&	XVxfLgRh:f6O#RR&zZ&OFL2=tilc|l藽U_rvp8l_lE̓paU<ª1;^eN
:D-F}ҀWop"ud1l05\,ϖڞ&snȏsAt@NHtbtnږtStr	fFXo	4!uhb'5 c']j}Z@=mYԨkk0]*c|1"_O}&ŠYc3zG9ttҍǰׄ9]KHx׌ݴ'O6`zSXNѭذG>,-mG˾7v_cGvQ\C(ݪB!,%ۋjіqnY)5

ǢXQ`OMz]݂))G޶YWʍz]bݮjja߹K
Qw~-]^c;,|pkmβkp%լ֤
79(;(Th)*ChPx4U(@>zFf	a9	ҪbL/M Gs?VJS0sAjԽ!JcMdB▻Ib
S-R^ ${E儎0,
Jنhsf߭Л*n)$:iWI~ͭ<ձ5X]@M'X&&᣽B:YST	m2#Q--8i 羡.W~)KfY9
#f9fDu]w0o()حN*E[ߕ]LljҸJB)mq*cg&
j>Y<M-ۆ|ykmKXpM>OO^Q+	LYE9^^_ѕy݄š*kіVˀyvqI5UUE\MҸ0C>!;$$n>IA
!IND>>#6qd1\Ѝۺ/؂~+aĽNy_Ͼ"bO^>LTuXvmwmIo-("_v\~!"XDWl x(4h6c(ڊ8;iHHdLFףP*^w TViXf\j@`)dihlp)t9'!v|<zhےM&袌hV$hhjF馜vzHz֤)2ԐWꖭ뮖'
:+S>s#)D5
JW0	Zq>+]6pPs}s!̹ Hȴ@#ǰ
_=.*4d0A*-	q{Vn]϶}1/+b.!~cz!S3no
/D"=tXOoVr#m4HlO-/\M)Õϊ`:IO+LVaK߀eL8wG'#3Ѝ3St\'ֵ 2SՖM $3#520=X0
oSkZ'߱S38u;"0o國=w}=0L
;1D]L	U6DD͢)b"	w
 thBNo$&X!\K
ɵ|M$I
rJwf#ײBЁy!QX"zW7'!CG<9슡!Q	.')QIR9hj$GboF

L071!
9Fqp7F(([&wBq0Wk}:$ĉ ]4ϔ'g$sӥǒœlq9^\!Fmf@#H5CX*FcI&6HУ@S7D`&љ!dlhA#a?#_쀟˂	[ϸ9rU'IM8n`Ja;L]DQ&4A#B=V&ʫ(UJ{0d3$)U<~H-u*&#P%!0_Q:Zl>R	@9TE([^͐PE"_n`"W`%΢8<ѡ5cg`ebҏt0d6ٍTE|0|=/NkK\M=hg0J[qҜm-b2ަq2/ZqG1k1ujfx̒Zd'o+/2aNi˸՗yfiQ|qslˆ9u&-
X\Ѱ
}MT!e=l~,ڵ&"]
lBL`|#E޴xT"~1.Z3@B9DYFyH,9z,ҔNPR9TYVyXZ\ٕ^`b9dYfyhjlٖ\Fnr9tYvyxz|ٗ~pYy٘a99Yy	ٙ9YyI)ٚ9LIyٛ9YƙʹٜΉ9Yiyڹٝީ9Yy깞ٞ9Yޙ	ٟ:z
JX٠ZzJڡ":	$z(i*ڢ.ɢ0:4Z)6:<@{BZFzɀ3LڤNPR:TZVzXZ\ڥ^`b:dZfzhjlڦnprBvzxz|ڧ~:x:zڨ:ZzjکzC@zZڪ:Zz`ګ:ZzȚʺJڬʩ:ZʪҺZڭ:Zz蚮ڮJʮzjگ**KJ{Lp)X)`{'/P3X0C 20,PL`
(9`ʚB;D[F@{z'P;
{+Z[˱X $k(;,C00+4K>8:˳sN|۷~+{HKP+T{WkY31  M@+]۪/M D@P 0
pg`ڱʮoț$@ۼ뫃ʴ؛ڋ/C 6[ڸ۪i	@
PMzM&KB2X01
l{DëZoU;$\&{jJ`p`/p'>
3ˀpI̵CX0	0B110"X	@WC M+	;lQPe„\Ȇ|˚ˆ,k30KzɤXçp9?Ca`ILX0,гv+,^)i60ȧoKr+8p)࿻|P7*i-L0Cf‹<\$,L`؃5LFMX`J.@
!@[-,>+/1 @]ٱ[]`>ͧ+)`C1E=
	PI-p>>[^
{n
k-Jrݐ˾"m:)Y[>6l``ډ\W>u-p:oԾ~*M^{-3X'0%+P۱;\[?lKPO/j9k? b?cϭ.>a+Q?tSUo ?q
u?Op/y{\/3/?’ۉ4s-Ą?߼ՙקּٽ00_?_ȟʿ?_؟.?e`.0_?_.[[88ʥ	;PK趯PK&AOEBPS/img/petthemeb.gifGIF89a5RZZr㳙q1fΜsrΌ{֖0mR'͔֜kMWc9BQcJ{Rbt9ލJΙjsBJZ1oRεuWhpvsBν1k,8E!%3\dc{sZRZkRƽΊ󛻜еΌcssZƈR!!1s֭Z{ZsFS!!â~Μc-3gֵ֭S!kZcc,rNZ),;
Rs{!(szDscֵc9-
99)RJs1?R!!,5=4$$$!!TuHHH*TTHUH>47
H*\ȰiTXboŋ7QIɓ(S\ɲ˗0cʜI͛8sɳϟ@
#E^GCJJUǫXjʵׯ`ÊKٳhӪ]˶۷pʝKݻxt
*,P!(֩[e)^̸ǐ#KL˘/lTR{jkӨS^ͺװG@۸qp4;ߴw/
`A4KNSÃw(x?^|IP |{GO_={E=YE
 hxvw{h3Xm㽶l'еGt' 0l|Vdm3 #WM@6PnJ̮~.JmJ,;|P&G\T88Gnx	=mcjQc֞=@4lI
0]
l`61ᠼ(Y/WԊ"ژe@TXFQ_dz]_S(4h@LG))8-H1̑4D-P#؊A6b$Eƪ5nxB
R<
~pw"#(<Ut=>…,3wiX+Џxh#Mohz~4!6 ;@
ty@$6(j$`IY*k	Z#qZ1oJ_sĄ/=e6 Yܘ`G&4'!޴&(vtx\cnpL[Roi#9OŪ.#\xP.!ֹ:@X\yI}K`"
]8@!񔉛m^KEP6_KaJEbPa܈45P)T"+"p7T`F]DRk
Tq|纥*.7ygw+=hPD,s!+D=eIܴϢBSю4YV UmP-(Jb
Ti`; ia
sa<'KOBH8*#	bc@xbIP7c]L@5A0ڠ,eWؕ&*|$GIvq
	2Z@74ci5@A9PMtz%~WV>
~+igsV`j@\`42%|:z)1nJո+EzD6kXz|V6eŶ)m
-:'X6`tk50~
m~'v@JLӼ͑*x
ۺ8m!?@l=͊θeW)׾Ut
˽b;=H6
0&QN2ۂ,ku$=:kMmtyS!鸑0e$$R\9|c'YT<@pU+M5#;$K""B{c	t
m	ڭusn٭_^cWx6i7%e R ,n~%H
)p}Wxgy8Cr+gB%
rRisJzz`45{`U$vozPB	Zw~GbWtEukFfgp}Wo7	\voǃ5g
wnbVMAl{9'U
ĆcMx@$[5IH	=c7x$p54Twk]0hFhEWy-|E#Gr&y'!  >za>Ds{ YP%|pR-YwJx~ tӅFu/8LFmF1|F҅wH	D7Kj6 KąswϨfklfoUEdHEdoBԔvb2iaU!32A&b/9 <c/)hS%y"	xv`C7k@FTЊXWU19(mewgƈeJG	GU\[Nu\h8^_cA5o5V<ΥQTazxubHX$G$Iّ$eP QYגTkGׇ~3ivWWLW	ti6		|-u7CI3TbDH[Y3~55J8IqЕuAp7d7IbYF؃WxpiyIb,vEC#EQ^JXqp|^H៮uUpVD]qz,NǔvW_ezaVhiJzq:lz	Z2*xEfv=fE9iw^ڤ]2JWR
bߙwܙ.	>Q/4 B9J04:y]qsW!GkV:*kȢAdyjzE|jkHX!tvJ1zj`AWyX~z0z@ڪz:eqDzbQFꫲzک!RȪ:Zzm+nyT C*`, 82XI*"zzYA[[1	ca:}_]aZ˰+Y1[+[!jq`10^Q&ؚ:<۳oQ!
"BFPb* 3ŞʑC\۵^`b;d>{hJBrSAMrRj>3 3gQDW{sZ{۸Ctf$0Hpk'k`S;+I;[{s`	&"?9[k`&ɼƼ;F$;Y۽M{AP绾xۿZ"1.sQMp\q|Xk<w*,.02 9;	B
|,D=L]R=T9ҹ*d0p]H0E>-d-E OGQpif2?o]p|m}E@[
u}akF=[ٿ\U٠]WMcْ]ٞm̫C׭Nz-xE-hي\0ԿԨ̱}>-ܧm̳M}؝(=m֝|ӝڋdrz]
|
-\۸|@=ޖܙ]}ҽJ\]?ב=vmލ%b=u,
-.5N!M0_/]GBbm7]LNLGPHhg=E9>piٓ8~D>E	^vѴX]1`­߯-ӭY=M>`nsQJ]-܌&.\MM3s
NԖԱ>|E \EֈnM0۶MڍN%Aw.1ؔ-ꈎ3>}֯}q\:\.?LQ}MoiM.L:-߁Q`6|.~>\ n̾m0\ZNW@CM5i2>O;h/*HMf?QPBb?z-t4u
R/^d=c08?yѦ S.pOp_?Ŭ|Xm}12 `.ܧfm]׾Y]>>i~ׯ/=_٬;o?댯GfO002dA>^Q>MGOM0GE\͏	³½B-ˮ:5I E!n0EUK^Eu(Wّr0Qhڍ@,Ǹ&1gpK/koadl+*ϹDJqrVNlE(W4ELt2ŧY۷pʝKxLr5>%`Mk"X0DLjAdxE8wtY028i`y5b	[c}7cx	S؍I2n\ƒO5P_,rȨbVjXR.B`ltqq_<Ǡ\g.!9~ nTaFPAesчd\m/.cMDF,iȀiDʄ١eݧUiXf\"ŧ}[ihYWbjpN_b
@|k蠄j(?txODip]i=.p"zjWZI*~ꪬ~*kj뭸뮼:ϫvk&[>ȰF+Vkuvl
kC禫+k,l'00<,Wlgw ,$l(,0, Ğچ<쳲5UH'e}@TWm8el`4`-Gk=8^ll 7l#i6ˤ߀`$now{C0@w8k褗n騧ꬷ.n7Oh^@ B <~/9ךP^
``qa/sO3oѳ`7pz4`'H
J0`=y@1>`lO0(h@=``9B~*lK_(&̰&6(&:$%A0&
4pW	M&};"
4tn@5RPH#Km-m=G0
0L;f2+y8Irvr%@@# 5!Y: Di:24F)PdHҖ0LgJӚ8ͩNwӞ>
*Nis9EYm]S:A$X*V
Plk`JhPʰ 	pp8ԁ+.J:ρd%$ZѴ[Zɸ걘KhZ
`W/vsd'KZͬf7z
hGKҚMj#kQ-cQlgKu/7	0d(GNIv  &
m.(U-	4PVv@3Lk5	$n@|@2Lprws	M5y
#pf>wE#dG
[0Z;B GLģ-_9.@f6s0~'41~n9Q]zLoǷP!Xj58 1dP%3LX2
7W^B{40fnJMBoï.F;ѐ'3`+57.2jB
?ճ-@9LSp@Qp!88;q_4 zL'a؜4e2Xvv
N?DÔηJ1#F@"i:#t#*ADLR Cpӝj͗;́rɱvôV:R87\	Qҽ9q3sRE4MFPDi{&7ủ63d\(L)G*7zhO=Et|/ze(M;S1,<$j7hSꌮG dš"D>=\E/_9xR#
 qO]& }b
Oݵt!_SezKsDBa_еh܃p͕OYQ02e0cՔxDX\IW_fĔ;49\c0TD>)2P Ȟ㸞j0\oYhi9	ɟ9	J	j퉍g)ڟɅ
j ڕ2:C)َ[(zhn@}9D"1@=h)xw6y8-Pgp9l቙y@EyfyG[#QF`#]h"zF|L=4YhXR&Jp=l>(QզdgtT^8	=tunMhZ[k*Q0Vʪk9١
ڪg9z8::ȪJ:C:'gF{Pu|v^
W4[q=h㓃Xj]{`3֜ږlf+ں}k3Z|K˧̕4ܬ}X4ޘ x'9xKn$Cڦ}ڸiHˉ	CSȲmӤ9mWYmiʳQݸlԾ]MݦL|NZa̱Uf
xr੫KLB)γmuV`$?l,hHJcqƼocA-.QCؔ`ڲXI8ӄ5=%>.Lvý۸!\I3-
7-5YmϘʭw‹
)^N-<殌M
^u^
̆;":~:Chgz	3:K0t `xX>!io]s|e|D
hƲDZ/Kk5GȄҺ:[E9MGmwZM=K;[]4]ȫYɏ{?d)Xx~1>o}U%a;LiegE칪۹ۮTꜾی~Ό᥾y$b
nDB0&Aqt[+~-4I|ƾ|65Ҿ9,:|3е8OBBC}n>oejhſF~b FBkb:eU^*,Nb.؎=-hޫwOB1ت(iTK_ȈHObiD|vsżh]|vChb?l?O~e+a#kvb/_=d 0O+bBfi,yH]@bY[9[۔jp#ƴdBn|%B(xf_J2[29 
(((1


φߐ8
 9
;;
P;;@($BH#
k$!"FGPpmhI&..ҨML@sF?dCdg0q7 b8‹`#	;paÇbTl.j4'W&*mB4u9k5b;ZlsbMȓ+_μУKNسk?~l(ËOӫ/WX2£4D
d΀#A CAf1pgHN)Bj'Ehۈ(70(4h8<@)Di$+:rG~\N	TIfX.E:΅IMS3갴* WPɈH#gO$|矀*蠄j衈&袌6裐F*餔y祘:du姠2	b@a*df*9S;j+yު뮼+찱J)&z|y՗-m+z¦z0눳^n#-wy9_7,l'7G,WlgwrSi6fV+M@De0'54l8<@-DmH'L7Ps'C	x\w`-dmhWV*<tmx|߀.]c;5LG.WnyRox̌_砇.褗H[޹鬷.;87805o'?l<g>|~a?H h@1P~X	Rw
gep G{'4PhGA0~ӀvL'_@@RЈӡ4,$_'DQC&o/
Bآ+b" "`FDE!K_
 w]F-OTb4q"Y:O\xFKN/dXF,f&݇yۀGP	(%AIA~OPN
/IxJTZ-LYM7τ@4DNB`dMlq0BhQSe>sqjғ\fI20SD$uL~O'=NϠ*P].F	i*Ύ'bd8#jrzL2|IA
P)kp4Lɾ-AM)>TsRmihNo5 fn}h\8U~MkVxOJjJ{dgFlE
U)ӂ]j Yh+[(K
(˷V 1׸>Ҷ]5;ܡjHw(re:mIJ3/A{N%$KջՁu/wT]nCnт kG+4'a]4hWz']ؖrp+SԬow[4b5WDx>0PL^7J_6i^>Űq]EհI<^|,3^n/ܾO-7fJY͸qw0_!'VF<Ҁ(5F"QM22@@:@XD&?QC*M&i
wƀ.1>!
ܹυk+0-0QffժX4+.7xٌ5'[.׼5|q*`n.$rE!N꼹̀}ªR?{f}uβwd_a#
ĿGq6&p4F{fMS׆nG܌@= Њv{<2&@a48e4t+]d,;ƛ;
Ymn?Kll'+]9[`%׶1ѭu[@xA)k}W+>̏dlQzOoi:s=GYχ~q;5T<ƾ>~VR?oD4>o̞W{}wh=jN&@c}Rnci@eiÄ>UUNxExlzoUwau?Mdz.}vnԷGtdiGg6X|QbE#`S&J FUP0w}C}38Y7">>GcM!hdA8#~ZTsIG7AX}%$ScSt8>jH^ZxRhR0?V@VEWN2{Rȇ'l؅%0/U03PSg1n^Ȅ[^S4`Evv|CX_rTyƋc^~f[\D/[``80pnu$wej1bPfwwn[h`HWxWl\F)&{ɸ$BeX[5=!GvX?hl]}g|<w0Wd~t]B$-`|r؊ HŘJrȍ7x
?A;YP;hxwGtIB
UϓviȈCJوY	|D_
PLh0jXY`}`)am?0wCfٌ^xWqDowɏy×g[qj$({Uwi?)Ws"XE~\Iԙ?{8&I
~^ys	uZ	vKet]*y.=3;AYSDiZWÜ۹q99ysC0&h D*rwWD	mႨv
ZeP_ɝ扟
iJ4穡) ܷ(ڠZQin!j-*I zZ̙(z*:6
5<ʜdePC:B*=?Un෠GZ:#OʜQڡ[ayI:p*zT*/$b7>y8*Й*ahU`IjJi[0(z#Z69ꝱF kV0	j*0ন`֟vl*PdIz:vlTʬ:PIߕ:Ɯ
fªN*
⺫Z:ꭷY|jک::hkڟﺩ*׺J,ꥵu*
ʪ+*KZZ
ڜ&:;4;NF6:\s
eB
:]iF y]x7hf]kuv^ߩa[$+F3:][g{ZrK;Fvh~T#azJ)1K
ykKrKkUK+DZ{Kk{[D[J˺sKEK!ΙJ+L>Ûʵ۾k9:{*Fz4}q=9؍ |
#}m
#
]>xؙ|ڏϞ?,D&nܱ2^P"/
Pn㪰-N;
?>LnE
W
.x-{O"^۪m2V.pNMmy-{^.}oǍ.N
f^D>FH'^KT
#~

章1N`؜g^0毝
~ج"}e檐
"3rf.m}n~Վ2bN̮Ϯꄾ
.]E>3ݺxV
>ʞsm^O|}5r{'"oܫp끝wn#o2"NCxސ>&#]3>n.s.޷>.?-r\aq>#mް`Pdo_{ء.Oolbc
e=O|?勭f/ޞ}.ޚ>ڈ_]{4Cn:%NJR1wXڣǏu{=r
d
oU>؄>ک`mᖯ
?oG<2C>S	A3B˹
L$!,)?!7Ĥᘷ㶏闌E?sZ?-ѝNRܼMUQZ*.xd	<:0%{=uGō'13ʬӧPJJj0gЦMv-n߆l&/WRɄ?1.k,(rŴ-_hqR%KIL
㑽ƾ)22[= K4I6;ڲJ	V0^b]Gc6l۸sލְ֭i
翨17v1d~}wMl˛3g9S#wSYtqտ|[' z7^ۃF(ᄷ[4\	UqbrzbKI|`k'l&8"yɆ
>P~}i\rMFHM%۶r&߲vjZYgT苨"Jc)$>"!wN4/k⯚,uDd{*rrqOة*qGH`,(+ھ>1+Du*mli=Wpp
3;&NKDŽDm#|.jviniYLu=HϽdX'Sބᝠ8ԲG'5}~vќwSHS\vtرDRz"GɸE.idxÏ#Ȱ17BY7gc}#
[-k/L4~k*:g(~w|cT.@L@*s%g䃮Gڐ~X:݌9˅Fܢ2DDE
m	1!$f?tR9vJ"h!EVJbX$*rv)fK
GP#/%BL"Gk)#$'IJZ,F#HJ2(GIJF>B=R򕰌,qI
r.w^2LD% \L2YKsЌ4I4~̦6n⚝8Ir4:v
tuU3]]KzhUg%֮6u:ͪ{PGu݉[cow=r+GM6'B/Cߝ?i=5ԕߗW?;Z1g5{a{qh;|kjz=!oT9SX/{BGt~m[6OwzG>4=\Uo߉v9~ߩǵ}_5qBX}g{}yw}
LTgU>{I|dWye~]e	zWbpkowjvHT"w%T|E7v-wv'}G}Ԁ$v}chmCxo5ZrvqWbw|VTׄEx腄gY}U\V\rF¥Gvr@X$GFgΦg/}8vW-k!Xto؃+gTgEdfW8Q^gJxiG\'T6cIdhjssW_8cxFkyeHgOExZ̦jXJ8`hWlHngtXdX^XU(I䘎U(X|؏4(w&T
GIIxY4Ԑ9ImK0$Y&y(*,ْ.0)2Y6y87	 ٓciB9DYFyHJLٔNG	P9TYVyU	<\9@`b9dYfyhjlٖnYRr9tYv9Zٕz%W/'O"w9Y)qyy}4r$fy)/_`999Yp^r9h0	Y0yk隈`a2Gm9Y›9B )k9Y``	> p9hI95J9	yia`
`Id)9ɟ
c9z<`b)9;Ydəc
	ɜ 8ʞ r 
0+&:P	ڞi`*zaɟH9S)I
$zkz'H*/)t0ɤ9CjV*Z#	:Vi

%ڣSDʠɣɧ꟎Ѧj
ZڪMw8>PA
9
pJSJΊ
d9:`
)<{T깬9zڠ
Q
⪝9K骠Z ڬ@i=
@	쪚K溙
~*0eɞ!PC*EZ{銦
%
1;eT/Md_]8a	8
@8Jzڥ9J-.Kz3~'R1۷a/k0;;k~[K򺹟ˬ[[+Kۺㄹ@ۻS);[{{k9۸Λҋ˽ʹ⻤*w%{K狾uɜK:+>zJukKt0Zk﫸?k[<[L;Pۭ)[}:q.
l`e*1 =ڜ5ppjIK\L:z=\0<lʚ˩J)sʮ
:@ƏƶY9쫞Z]kIC:IE-3-3kEܯ$JA;mŰy\(
L
=JMEm,jr~MݹL]՚OGMtuXa
Z c]tֲyfh֢	rnuMkxyxa]PSյ{M!	{٘H)ٞͻeytYt׊ר햡-ڂM=uM֧=ۈ	خMm؄MHMն
Ӊ۹M-ِ^mXM|Н}ը-ҽBykݤݴy۝ɽ,{ۼܥS-yަ+G<
vM߱KKߝ,k]`#	îޕ.ʝ@:-dqܞ'.->)ΰ
™<!;^=A~CQN4LC=c9V~sw橼[MEJjvl.]n
\#tN#J}4̥`|Zy:%=niݳL<m
҇>,kˢYFnzNiAFd4OYWOn_]\n.
έvm5K 徜4#qE3O8/CO|Fi]!\M~;\=9P_!?Uƽ,	3)_bR/۟;3 hHΣG{ Dȃʟ^x_]Q헉9Ydlkv
Gп/:MCk$Zj$yk_Νq4䅏e7Ϟ,Nz~~/zz-ɣ#*LvkC\߲
L$!,)?!7-CACCB3<>3.ʞ"A6m	EիXjZ׬_GbhV#C0lI^uFɗѸI͛8sɳOr;hQGiM-HZEf]$lF"35حjL?L6ZN2Iϻx˷߿%
@z
;ʔŸZEkP׶\YkMU.]MkO5mM۸s&fl*;Y'*mz+Uɺꮼ.iZlWZB@y+JFjlc!!k̖vAHܾTõK`	׹TY9ށK|+/`pVu2LyOZ,BXu<1%R2JX0C리b.1Ll4TTt|Gk}v[l,߼~_C
<;v۞<}gUڕ#YEL.‹%vCb
3i닠>AC"D.&P &D6BOooY`6&M8IuAYaظxxJ-\)(
I|El.z;$[ԋ#nӰgU8QaFPx/(G/Ƹ=Qy!h:xN2$#K1q1qD5 "Ws(pmvص/]kzGH:-$G<{i14I
٫pv@?rSG8qlƲdp+%	mk98|ADh1ma=dA.07I9N&h<dڱ4zbw-^wIB|1c&VƲhp!#~{I@1QcQW`BR>}Fs=e,JA#є"4%ӛAKw}(w1DEPgHۺEtN9AhWkLrݱ{@aM;b6_ʬ\?f_t]Z+5p{6^i-ol|Ij~8NoKOm~л'q	c;7n,rg%\}r|F$oԆ9O8WLsJ/z:qmAiЗ#iOWҙN|X'whջuM`MnOzt4`![t6m%lˣc*7(nُ&׸nJN'<.xydyl3#ț^{?1I\tTEB=)z(֑ct>=a>~ПWӾ-exDP+1>՞=r-~=LOj&[X #:n 	/>?dx,
7%7U/zP|80bhw=׀(rX5D4Hg8W c8$/Xw'Gc`-Qe.ƂghCk1H
pXdCkpg]_zLB-˴mVCHзLr8qX}egvow~h\&|p`؈(F8
jwᖈX0uhogxp؈qwF$an/X3h8VCS,$5&H>>sX֘*rƌԋːxeHs'ȎRkw0GxaȈXt?(ɸ樈xhN煡:3whf:Z	ĄP	y0{|~h}g%B-` HQ]5ox$}Wk#t`~gyVpjEhT	c"7<"BYøzuz;#`LY\9uSE`rCdfyF
ǖ>^৘)lIh{r}yX}}ó97
d1-Yvh;Yw	u *D(bVbٌ9 8]K|ԥ
ב0VaIqYy1I
~Y(SIZɊTr壂	+Y2tc^o/X~IY668?hEzc RG6ozAoZM 2%EJp)O(k YʙD)}m6cX?&D"!Y@1zidwP*p7eix_mjUo)ASewTy
|zZxhz0*Tj~
UZ9u	q(q&eȨ؜j*;7sʪUIPڧ*OŚ
qʺԬJ!eqZ
Sȭ訽jg}Bja

*
Tփ鶭Jy|XV{Za8C%6vC6P#5
8u=Ѱİy8EIkGx<:s::ȃD ن&ˏ;jn2ֳi=|LS9;L5ˑWAˀCc("aWAbu?:wwTQ>@˦a_c 3hk&=B0B PGa:Ȅ${Z~Hz_vh]j@G4\KԛTA/ZR4
t!hINQ%oDW2|hByr۵%jx vj_{FIF@滢;ø]UO+
6lF#PlZ™	f[p˾rH{ۿ:5|Co
OKˮښ3G1X,/&;*3,85|P8D8z@\U;,=|P?|PćjhUG*pj=W]S1ًLXfȻ+Xf\QhNdN%:zY:L2[T[=	Zz||L\̕]HXr0:6#kcB;K\ǭqjǑP|%ɫJVfTɴUcBN_{"MDd]F8H|c$
qKw&@cax`I#E4dC6̎xY,wc|%f};k42C\mi Z[hdB|fJ^kͬA@f搧.I46ekϩQmfmg㥰5}69F󻑐ҪkW1-R,o,;E<'.|O]'~	sj-
=%˄Пw
]NFtFׄ,";+2}_Ӱ
Öms.|ٚS-kMK,؞m1-Ldڧ)
nڙ۽8uٶ
-
[u	u<S	{܇&ƴmܢ}=	2ڀ3qO_d]1ہspǫ5.V65ӱ9oqQ'PPH^-
9
n\\eV!Lttn
iE]&ciS_V==Zݳ@.N7
,EJ[5_jO_#hqi9^Q[ۤ4'Ts0
.;ѐ)xAJ]>y޹
m
[-.
[9ܷ.9y_kdѐǢIhG-M+-+®!j][RYHKt4>->KG-LV6([cehۮ>^nTb@$OSHcNOQ1*$ǣ>5.R2sYG36k8:O3<"z	\D?&×OHJ]2^>7Z=TiV%Zc_+S"g?A,Cahp-YlWSctlmM
[[flq_/.mU@D^nȱmV.V?-DB;S%htn-B}EbB
(j
v-Cr1;뽏.-3M7m_{& $!,)?!7-3	ABGŭ3<"咗홛YSG*\ȰCmYz(QHȱ#~C8ɓ(S\ɲeÈ)Qwț8ɳ簒.
Jѣ`Ɯiq^z>Jes՜@jʵׯJd*!WJƬ`ʝK.Q4U,kӭߑl
׮È+ٚO yʘ3kD4@ӨS^ͺװcVl۸s]\Bh+xjKNz62A75ҚƎI;ߧ/y8wBɩu8y}5Bd5,Jc.%(,8 h	Iv}5x->Fzn\/wλ+G{"
_;i-O}GC=Lٷn/fo[me?K=>mʛf_@Xă
̇"A4M-yR8m($bMnLDLxRC}0Ƙt"@OaZ9iJdDc	PS04ԩkLEl	Pfc.7k'ࠁdQÆ7-rJ]ƥL*Um
832d6e*ʒũ9`	9a|#? =A8,PITxCRJ$FȞ5-i-hᖵ'fFLdК׌(>yVHc1ʥ.Ř_sGG/u,b\&ŲyF=
Ė41Il$T}Si-$IC"΍Y EvqF;L^ r%,S8]*S&9&=rD1ht&U.mhºu8pۚ6*sV-f
u ߚYcU.$eOu)+)"Y."Ԡ]7n{F\3vgh\	4RB\	',TM~9`D8bKV\><;BהrX'DϝHhSwFTLXduR˺ܷn.&uVR>{=s4ڦH׻t7E1ײ-nm-
t5ƛaGs38uW~&	Gv {Fyk+0p||c_W1ﻷ{4og8n'4oxo#8g]g`5X~`
(Q;g_zʰeS ffʠfȀf'(REAj'HpD!VPheE]wunp6cȓf72ObL$&łQUXzHfhە0;j54LJRh86w8džxeF
d.,PDZUGmԆZ
dWw0[KCV.vw8.V65~gsf'ǂY_懟'oE$fט.[jK8z+cxG'kX=]-Lԏ{X}$)S9
7ɇ?T5 }PDɑ)ԋ&iN(	@*I,ْ~~24iHw>A@9V;	A/?1	DFy1ԔN?P)B#ɔ:Y=t%e\yQ[3s!Lfpg^^S=N6w)iXVW:RCZBhy]yy0(Dx	ZgG0i.hwOV沄wtj×U98ε(BqlmtrVfxi~xDJ6l_0r防Iى/tr VjvVbMͤFڙ-U/biљ)keVH}QVFn|ך
mRt*jnSPՠ}R/
fҹj)r_tw(Cq&X(ўSy b$3kŴ5(qgUyh1<*uA5j/t91tQ4##pY5+eP	%ڡLzN*d'+R&78/)5[r.gm]iPy<@Tyj
=:dI]ڤ J0e
AJ<Zs):618+:䳦F
D':Ө?ꉩ`ZZZ

Z9qŭz[byh%

JAq֐sNu*׳S^Y1zsSR89&){ïih	5K5
iv@GGDt%2>uXҠqױ(4ěmFGJ5F6+K}fڰ+hٮqLٝ9rIn"هᲕOP+vf%ppiy`^[EbAkrb0kbh;skgzwK?4o(ǷNo0`;?v;*:rԌղIZvc˴n,yw?Jx(ST;IzR7qpۣws|:U[Z%8YmGګ{d;d%bYx-;쫨MmZ7TQ)93T&Kc>
,>=I>z>!†IL̞cI̺x^'htdfkƱ;$vFB/{9Ĩl},\,9\sX{@Y[wNS
Xό	71gvϋ\y.p[-h-o,@|/
.1-Eәc7-Z9*,H?
0lh<F}ԾpkN\AMH&ՆFU076S\gh-*8l
pXZlBnݫs	)DuP="y}}w0eE\=؈!.
+	#ͭ0$/)DH,l]υ؟}3W]E;
={d,VM|Lŵ]%ȸitJzXɒ؜mۅ-Z6Z17l<|YQl+Q-#O)O^%RZ@qkm[$޴&.RTNP]_a.regׁk>SKY.U|/b}.>^"L牮ΰ9mL>:i#NA
(iè#뺎<׀~
^,q~y(ʾ>^~؞ھ>^~O&@1ib _?_
>?_ "_&$)02_68:<#>OO

BoLPR?T_VX@HJd_fO`Z9ro
Z "`&O|o&Y?_?]B
|?_ac1p]`
#P
1P&?1`Z / 8v__+m /G?_%11@X9`o?e9 &l9&O&8"Z"&&#YRZ-mU)߾ڿ1

9
Z($BH#

رB
K	94&[r@d"	ZZPAC
i*iǡgO	bppAӧPJJիNaW`chD@4C+*-ٲLHHbwqL65&p0ɤx-#%dX5j%P@:qU-ˆ2"E)RCcGƵУK-hkHl޹o^ιK BT,D\fvx
c@;UŽ H)RĤLD2(^U"#;	&a$@8(:'d&,#]a9-[!,Rqqqڂ©jꩨJUd[Ϋ;
ilLHp*Tl1x_gw`]\18lmuᒥ,C413T[4`#M;-b8QF")+vib+Y	ͅ ,p6,p-ws=N=8Zkr2+r
l!miBEB	(ӀX8
9T[Zk&‹k05@voKSwKx(\ޒg;/COf=+蹃v;/8'd+YdQ2>Oޯ1́ dNm`ü:[!Ag@iW#p8ke{FH[4\BTB-obƝ<@uR*(ĠZ6Ć0)h)ژA(8GHEU͸"34)eO!`QfLcT,6ƠAyX̣*-Qw#!Rv0@H{\j$HHVRz 1N(GIJPⱔ~
@JЂ
(D'JъZͨF7юz 
HGJҒ(MJWҖ0LgJS68ͩ3NwӞ@
PJԢHMRԦ:PTJժZXͪV՛;PKI։PK&AOEBPS/img/search01b.gifKGIF89a@)cRֵsjEݤrl	P&mM)mc帒EvkvxBJYJR͜.8G񜭽g֭g9dm{JZlΔ
sB9)c{PkksRƽεlsε)k!ZcV_ƝZcs$)4NZ1sRέZ{ƔCPkYS{cck1c4sނ*{ϒc=X潁cｄaν!MUs1cR罄BsR|gNJRs1sH!,@??zz 	''	111'rł?	9323'A1@}*\ȰÇ#JHŋ3jȱǏ CIɓ(S%
h/_ɳϟ@
JѣH*]ʴӧPJJիXɵׯ`ÊKٳhӪ]˶[[R x3Rݛ ኔHNCKÈ+^̸ǐ#KL˘3k̹ϠCMu7L9And+ZsͻNR#J;jy1ME%ހh&` @8dq(RH!$!,@4 4hF#\H@t(aiH&	 B-N	ŕXb_ЈPJIefie.(@n#rbf\!=kv6$Lj衈&袗bR	fJ|"Dj%gNpi+@16`|Zؠ+loL)XjZZYʊ,_n/8k~:$^ώ"~9Yh-b[ui'(+#Wl9阡.ꠘwDc	+@50>><*@*d% d8}TW
pbH_f=e]ꋩP˰&܀你='4t|w*D$O-
(H2Ҫ0.^`9V.[eCp}٦
wyr+x
P.*( @	i4O
X!*&oGx+I#E*ݿy替9o$XK̚HY$;uSΣݽsDi
`Bӣ^}w@}HzFЃ&|[Gd(pf;#9?~B@zM
uUIVA*FY4 'g9|
d@^P*sǜ>4`{ݣ#:˃dvLcCv5^!sSqӤ6K=SP?MAJ""%LyU:XeVЮmsy8ˎʊnetvPdb]JLK@ ȪyRV}UUǜ}eQڴ%YH*ڡRuz}A@YK\5mB:}	,"x}UF9*Y!H;hXAc-ٰ
~tm
/=#|
\H#^:t}bf̠c8ePUF`*o}ۈFM-g,&+brpݷfI$c+ #u
`~WNo^*=dA[2^
vӊ<,zT0_{=_t2I	F i4,\Tnʴp#2_`h{ĺW䶲C8+E](zD
yjg!DOlkb)žHA SgqtQ11١I&+J'02:4Zן5	$e/Yp2"X$ w0BVzXZ\ڥ^`b:d6zhU$$v@2K
7HJLN'<4lP\V|XZ@,El[0`\bLlhpv|x\3;+60P+ȃllr,ƈ+Qȃp`W̃k`a-L_{
v}x]p[a}8Mj-lN-PyJӘFԷӞ<<~\|Ө<v}@}.m,ҨEb,{+ەȖ-dƭmLz-l-ߛa}h
phʦ-ι̼Т\ے=ˉQ
^,,=M6ݫݫ?
~ ;n
l"M&GP+YC=9cˉOk׃=*>0vGrs.վLȶ�^G;`]-pmS
Ɂ<>u,ɨ^/?ۮɃ+/.B"O&nэ\Lbo][N~<
P\n1Am6/ymX lU=#]6O./UJOF퍏^`ObXḟlGm'-Nwmop\d۹l\
+n|-ҏׯ=ǟ|M_ǯwo/מS',HAC	/E0F
[+ 0Ohþ]̑!ڳqIΣԠ٘Q 0ҌpU^-0KuMT'K)ȱǏ CIɓ(S\ɲ B)jQI-sɳϟ@'ѣH*]ʔBQYΦXjʵkH^ÊK֧1:Zj#TTr.ݝv+^B*;~+^̸;Qgs븲˘3k̹sY2)카ӨS^ͺ)hEM۸s/~-ylNqFXμ$УKNسkνËOӫ_ϾOϿ(h&6F(Vhfj PiǕh("So4h7"l@)j:)$8L6$q@D)bELOf\V 8HcU)1Xv)ti$ IfPA`(
k<"G`IP_FT
i)駠*ꨤjꩨꪬ꫰*무j뭸뮨&BH~C
zl^0z(qT@SU
$ӵРĸ)-km*]-[B,`"9T_(TB{
q$Agg1>HS
ᦐB!xA*|sˢ۬G4یsBG)0
+r"k\C;	)}9Xt{-FCG(.P
)9xD
d0肴x) 8O^L;ͷ49;a{u[e_*$n#Zq1.
d?/=(xsGN+A	Ӈo:#@x
yf/!7-}$Zt8qO\b(^9'H
ZPWS7z0|ו<JIP6?Mb\ܒGC%!|͋ȦCY]<偄=!ܜbH9%`xJćAuAX+Oaqmh<Ђx̣> IBx"")H-αihH3M
c	')umZPR򔥜B8P<߀0N,YE[ Rހr4.؈_MpZ)8Fc"S㶾h@x4Xfy:L:v~g$D	<MBІ:
%8F18`B#TEluat(Ju(MJW'=p76˭@s8vpۧnyEcQ0W|Wu}ͯ~/c'ZfI
	[Fmu
iKJZRjS0rGi)OdFDq:ۢ	+XIe*;fJ@)9\
$(w^A2wD?{"7=0ȱ4z*hN[7ph{ۚ6%,=
6M b
i&<Q{KkRb?[cGpw΍RT26~
^U.Uh%/i%g`{'ԥ_wpcŘӚMrB|}ׇ
:sf,6mBN2L2ߡ_"%B|.x@ß=cnKb]OܞL$^ӚGUriiX%\)=#SД>y{̧O_nH[a:;uHlMzh|VjدpҢ.f4<4jmq'ua9
z6>7؈BA
hlHhr^Ejw(^x:$/O>fo	J}>ukE4}lo;;߹ZX6R(Ie޲B*wT_pCOp1/u1%qSp4xlymwa\dk'C)37`zGJ8C 3r6BVH{@ 4xk@752BGc=X|:j%8D>PIk/Xu'YW g7B~d/f ܷb}yq "!r8 Wjo&}Ue2`buwV)XToScS0DڕSgg_tpPWZyaxZOz4iqUI)V0x(BF/q,ȃ0Vkr2'z.?\je2č-VfQ}QpX X҇~8sG~׏g{XWiPUv'w! 󆉟^eqRl10UgK9\(q	'yXicxRÁ#;-H3IPd=.Cz0VKل8OpCz=(( /E2pSU鍞Y))MŤ[6Y8„1qyuI1Y7I]5I	PxؘtHdɏm}طisȘI9yٙٚ	Y陹y	y)HPueb_Y!@y
5 oP79)Fd}";Tg2j6YYRgxJHt1@i6ӟGn\TVtUiTXd(zy\7;3߈tʴh_⡷D&.pق<3L.Qr3t*<'		7{ٚi9YY	b*V*9[hʘ]znf:IkxlxXrj	p}iz̙X/ 7_xp$L 9Нpv`ܩ_g	`2lesOTP|8g5ɒGꟐ4Pxɪ#Ơgz&zK!oS8.V)\Je5/D&CUs,jL%FB0(S.ʟY02_DĂz3ãIB	OJtx+sJ	nhVzwZ9duz&۲}Z{(˲+$K7{*K~@&Inyũ!@*&_٩_Z{&o*&T?PZRSГiJH#]П{7T-s27:.?T×\%U2#
կZKry_ҔS@U'ބ*5$(k|Ps0[۱khH˫,k^Z[2f8*+JHYv'&xbPeMPkwJ>_J>Jd|*U瞝ZR v1p:u)-@`[.;/*Y8Jz3DICcҹ8\3	7Jt5qEaFLĂ)ó_":0LkƋTͫi:һ4K;[/i۲*]k{Ëǀ@+*רErbb# _kjLv
oW>[V^`KT+Y+xKd2IП#yy#|a{.
z,1Pc_K{ݻ[!z\ʦV]KP2_wP,gj۳22UR{8^mpX<]`֙.@c	D߀^@c9Q[B>U>LHE.{͸9|uݰa|HG~<_ўyhnkpb´j&@0DiP~nॎm=^1u=
P,uMi=(^,N\A;cID>l0m%L`G=_ޓ'Q3=3ca!Ŝiؔ15KCT1z8
33pQO]—l/g3^P,4s?r}lîsMn4n!;0@
rѠ=DO FPnOP25.QhXG6	z1AJUUSP77cͨOp7S1iˈ**8]X(o~k5U$On.!P?gP]I7J*JI44!?SOi4?!]OI',HAC	JJ8!)*4̩$J)8!S$7SK)Ͽ$$JU TI$Ç#JHŋ3jȱǏ CI
, !ܼ0cʜI͛-WTϕ$
UВ7V>TɏOhq

]2S:Wzk-\l6
pqdKh7ƕF4ѽ"^y0ޫ+Ṍ˘3k̹ϠCMӨS^ͺ)I@۸sͻOL-PARHH'@*t]\'k}b]Eڴ_Ϟ C
DuTQ&h&6F(VhfF8:a[0\dy0:Ey祵h3>Sxfm7]zs^T H.6jF*餔Vj饘f@ʩ>u)w"^Y1㧁5
Eep
fZX뮼tPjlƙjY
%ws:
fv+k覫++"/쉪>dn Wlgw ,$l(,C|F	<@-DmH'L7PG-T,{\w`-dmhlLs'4Mx|Ľw~{`7'7ޓ?Un嘣Byw砇.褗n騧ꬷ.IH']@tyo'7n;P3BWv;/o#?}p=Nِ,Rޣ:X90:>	^ Aέ/^Sx 	XN^..l]H@Qa
P-,`CTpHa*vHO+!CX9,h>`“B`QM@E逅H${IT\!Tm	4F5{cW/0}'{F1{'b2CxI	\,\?B@O^Ғapow(	Z:ҖOj(Rb4AS&L8Ĉ,Ikrqi,8 F9~&
f:6+.@c yOhs,(>$7[3mD59͌PL+w8,Ry;F@̀
*п,FmrE@Jo\GG(/!Mz2J$RiMlVAzP̊
nt)LQKe$@jҵ.%#Z&QumeFr[FlM"K`&ms;m(LBW(AT^u% aF.dq;nllus-of	&ov+ ݵE׻G|o4E>X
>o#6X&NEOLڶ
"};0/]]Kac
kz[T.{|D)r;Ѿl"d'{
az|?yE؎SFq<ر7ctM+
hFAG	a?:VJ@Zz> 7J^M72dbRiLgCumiN{bBEM_z!k`-$(
rt:Kjqضr:ہw{MUnt2%C҆7mm~])sv5r!5K x8q}cZO?=>\:beˍݧ&~o;v8iN6ub}'[:1\z38w-C|q%>~[nݎoS vϳ͚>JAjp\P4cl[~xj^z{n@k0{9١쉞J wWҁ7ÏPRK~>Y(QC-8\_#XywxD0燇H)8 Ԧy|	c Zxpi~wpم9)|6{JmJvnvw69zr:5H%8J׀3lj
s*[RڥG'eبfJF(ȧ:
r^
ɃAQx=I)qܺJ>qws@B=D]F}HJLNPR=DMMXZ\^`b=d]fVpgnpr=t]v}uւ~׀؂=؄]؆}ֈ؎ْؐ=ٔm֊-h]ٜٚٞ٠חJڦ}ڨڪڬ
ӣ}T]۶}c]u=۹=]ӯL:-M}J
ԍmQM]}w=ޥ
=@ ͍q
q4Q7- =߱=n'>p"2>N޶M]>C^@n-^ֱ>f.2ۨGӪ|1
h^VNӺ~.ێ{NﾮMo=)n޾nz~]>X#?:<M9.mLn@-wMN7bX7EoDHO__NlV>ZrO\/84>~u1]/=m&V?suC5-7m݂m+oߑo栏O^Ig.~/]O߭?4>߂~Nnn)OK_ŏˏ5-֟tE??o8TZ<',HAC	eǐkLjшSQXݒԏ呴ù~g;L9VܹBsil.ZIa\ђ1\ɲ˗0cʜ9-]|Iϟ@
JѣH%pͤPJJիX[-s `ÊKٳ۷pʝKWڦ^˷߿6È+^k0ۧ#KL_NZ̹D1ӨS7ɔ0װc˞M۸sͻNȓ+_μ֏KNسkνC
_Ͼ˟OϿ|( q6&
6`osNThfv{H(*a,-S@(b8:gb{`{$\EPBDWRem;nw+,lhH 	Y%peqh*qYX e˜Ht&*
f(s>@,y
ZƨMYi&9Z

BFEk+)*nj+si( |Zle
Ư`*qY)O.fedq	.0mlժ+$X(zb'i潅Py+`.)Ai&	/l˶`[D,-o<Ɇ0{ʑKskiv
	`0\KM`?b'F?HW
0gC2-Y;/ɮ0;L/X,wbMPms(V-t6h0CۧMKPFknA6\
^
G0,ٶpޕ9mn5 1vNғ
n8&c+rͺ՗;kW6̲҆}
'-
`=5zˍ30]|_XDM"-1NRR5.`Þ)B
j\8J}[0)lZ#,hy+!(7R.
0HHKa#>aX*8]`4@d"ԟ*h>	sJb种a%c8RD-/}|2Z{<.)(- 4<6wr*T%ƴHiB@׺xͫ^׾FV[M@9P{R_ɬf7zuekgњiiSֺց}lgK[[ŶͭntEbZK7H=r$ЍtZMvꦺ
x-/zѪoT+ڗ~fL[kN;Sj0'LaI.{@G̝(Sg.wƱ1w[@LH&/PLOX&n`LhpLgιx.gπMhЈ>.ѐ>#MNҘVp3i3oӠVCMj7Ԩs
հgMZָεw^MbNf;ЎMW k9pn{MrNvMzη~ `,H;'N[ϸ7{ GN(OWG8fN8Ϲw@ЇNHOҗ;PԧN[X:;PK͔KKPK&AOEBPS/img/ccapp002.gifOSGIF89aX_			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~,X_	H*\ȰÇ#JHŋ3jȱǏ CIɓ˔K
|i*&/m	S&͚>ids?@o
iOB&ݹjSOF:VWfXhӪ]˶-EivFJsJ;0o]r-.aaGv㿗
WƼYs_ʟ-wfsiρE&װcg+۸rg
NqL%>μsK3:H}.sNm/ͯ>| "L"F:򑐌C(JZ-y&7Lr9cd<)ʱ-f#%*UI)c0XҲ7.K]-؄0Ib2/Yy4Ќ49f0܄5MMj_IrL:v$B(oS6:>~
@JЂM@'[2О
G@`N!DJ%N5pS&Rgq>zG6tQUњO!&sP
$t(;
lhx)1O	4	_$isx#
qh9 9R;Y|cf@08KTu$.ɴJ6EWv#n+Y+ցzyZLGx`s xgݎ&śVCg]bQV4de31jl#09\^Is7l02v
		1m'
!$ɖE]gy	DB
D7] vP#'ՅhLR&]ُuu0"#bpVR!%acqL}Sgs(r`9X!FRf+iVqmnqzP	0@;.P'dr5Y#:IC7(1XiGURr<D'T#)-Ws#zVߐU!	^5gXP2IRnP:K:1`a!!kAlAG @'yu= pY 
/g
i:bw3\-v,y]<͏֡{~?	Ӏ!
MC(cՀX5fY3nQ|&Qd
7Ԡ <nԀn


ɽVm-?SaNՐ
@ ȞL(Dc"a0$?p(,_02לMxJ]C_q?L!yNkmnBMX!LsePUX
kj

moSqbu/wX\܌sR]RSfLL\0/w-p躿@aef\#2ֿү,"s`Iiȝ`ɯeB?$XA	y}%NXD^G!Anj&I)UdK1eΤYS$@6u|kΞ?g~U2>NZUYnڕA(<>X,Ōǎ$)[qΥg]AԻw% 3)͔_HVb%O\Y%c[g]tʻMUݑu뎀#,0la0	)۸tg75ת=:A|:w-+ϯtOW}}\g\Ƭ}p3N>,B﷌q?0Cʩ93;K	șuj6qmĽpDo^rH"Rx{4^qFaӱ+qJ|>sL2s$I.t3*[Dx3n7eB1F6t?eOB[ړϊ2f@ҐN930DG=LҲ2JKuPMOSYbԣ_}ƚV_MM4Xd
қ3VYhe7;;d=֎ruuW^Țk6&H;buig}7^S^~
-\^3&suIFM5y7՗:P
;]0sc7lI&KX`Lk6s>
H4z
`6fQ2RN0bYVeefgTIYWrfmaj.?kG竸ﰡ<'fUk|iz*(+
$W8A(AAJ겥[Aixg8
d!۾@WA;w(
#SaŽ@
 wCù)>WxOxK-D(4@
lHGح#5j#R;ZZELŔ5mXEFgjd#FKEAFb;>Gd+gTCaFjlktlFƐ +GrčJBo]zk yIiw\g(+ut
K;ͩ#U} 4JՉST&\Ӽԉ,XY͓ZUVZ^_}`m%VY;VP@aQf+Ega	TowJVZVJ,I|o¹v&GM1h"}hhhvT@ eC{b`^.Ρ#JJ9\P	]^LC|%
*nf<W[GK@NJ	S#Y[Cej._]/FHϬDr1N]ݣB[S¨"ӅlU
	֨\qIȭG|h`vTLbBV*D^` =QavlLLI.O\lv	~LTt	
h\p^KF`g؜iCۜͅEȃEn>?(\ $!39p;9
Bط(q
TR9gxkmvcjKLW
W͎cD;]/gnw	[umObN	/_	i	4,V#~,@!Lk4 fDH
b4o
PNOl>,7NHso<
WEtTbua2s܀k?PϻD @4aPjMTc!+,/]gWI]%gu`?3a7n%έt((T5w=pq:X+S0Evsg'^0P#yxxxxg*WWմǠшc3󀭊WXw/*Ew{gwSo>GHmoiI4|xߓHDKNǹnP|tCu?x4E>f}QH}_@oS z1zEՐWv$\\	&~	ẓoEf	zQOM	EXɉݺߎ/~0nwqUI9Gfޯ渗1}yW躇Bh/>1NNƠhZI73n „
.!?H`$#0I K+ҬifG@4'РB_
ym4фH&|j;>bǒ-D >Iܖ_Z|ژ=M@@(@A?H	`@l7;U¬G6gO`<[0aÈ5180P~ȍ`#ʟ%UTѳBu sw`Ҹ_]@'	}	DSA8 J8!B
R!^@8) HZ)"-BH\m;-FD6=#s;#%%IAђ|.Ԓ?4ґ$ِ^u/{A	3LO~]7e3{ѝE-T4KVڔ&BYD&\!dT0򍀡e))7CL]*T.+?E#UZkmuW`5,@" Vrd#}[7S|/Qe"%PQ	R*
)*kpfqht3QZ$L)8ʇ0zz1z'lnp_d)')oʪOr/Ü*NBHY)A0Mfv;H |ֱV_쒙L4c7\C}#03fT@7π]Bzc.d̉kwtq|aAe.d%Bt&fڥükم*tf}5ԇkl춙dd2}#www-wQR/[1j:	JzK(T֟	!, CPW-ad%hS{C9aڞt*r]-Aԙ!1B0]%71[g8AI
Y$EQތ՝5-!n8r\)h8/0Q "
S$H-GЄ"qFr 8AUrt*YAd![ٲd'CEazq)/W@1eD3i:\J=Ҽʀ	Of]4وqk5ͩhĤ7΄ s&)tⳟa))@p?PQ\=	w4(D3Q5TA(9%ZQѢ(HSRt4AJ)Ғ5
#Jcӝ<ݨH]WғPRe+iBrөԧT]H5DFBmi*W
!j^b=-n-6!׹ҵr[TUV	A*_*P=ZS浱\&"+R6plJgjfrѤ)B1+ђ
M;o&gicQ].U0W[@-p֗qG[2mnpZ"0[.t;jbҭnނ6mwIQxgI${˞/sF7_-xf>0#,n
I+
sx	/M`=&>>|Ŧ˩Q,'.g+YBQxD96Bzմ.4>2KcN~2,)SyrB\-sYWfB,.{&FN24̸.܈[vf6'93Vߜ8lt>e[ą0[{PƁF񠑫9e~n}Hy5Q AJcĤjJ:e_Ӈ{+]ɽn٭%lTW]kM򗟭FՎٷq}Eo6-iu+w	KS/Y }.Wro+Bfv@oj"83oU9yWkI艷⼮Hٝj8rbVuww9i^6E7ag@4UzStǚH(խ.Jo:n3V;Rr{F
w;kkt	ĈO|^a<3s3o7~>s؏>Q{????/?8?`fT` *- p)SF`lA ^hYSvc.	
  Ơ 
  & 
&T!!.!(SF@!^Yv!q!!f6VaM֡CAa! =	!!N.b(#F)$V%^"&f&n"'vbޡ'/! ҡ()"$yb"+ބ+!,bM"֢-2D#."02%#11#2&2.c"323ʡ)>cD1Zbc1jr#1zc0)#5r0#;;#<ƣ<#O#=z=4#z#fA$AA$B&B.d8McCVE^$FfE,"'Jdc5^HG#HHrIڄ9IUJnJR:XLJȃN?
ԙdvdP6QBQ%q!
\A%\03 @TR1ep8|C8 X6VWf>S…VE[fCdJZ[[bKn@V7A`K(ChZ@CP\
Z[%Ufg^Z],d
Ձ 8Dm_B^\hZ"iRiJ@
RźfGT/RH	\`A'O
g%T'I
aJfn>DPZ%|~lNM'OئT'%~TK]>u҅|V}	'cMO.@LgLgTZH|7D| 
~NWڗg8j
lHTMPs&|R^ᖋ"(
 ;TT^LB;|u
$D)m
[:)]-VRxiH©i$D>D!>:bTX.Tأ&b!٤W~䥢Y4&5f
f&{MD'5)ҨJpiFIŰ&Z*R;oHlFgA^
HWi CtijŒ6q
Fٲ2kS$vxIFp޸HMb"B;lJxE4ա	[0"3
rVN#T,ԫft*XJYEIO\KA&	<\fzdbf}dJ+*JHGH)RW%k*VjMlDԭkdRbIDI٢D"j1&FjLit
/hk&.N4Š)٤]&HԧvjaJQn&TEbʭ-o/1of)pl2B4F&nEv#i* >0

0ZhA0sp̰A#^=)3*XcY1*mB1//p910-*v*0x1=C}J)iq)qM؈XM8p؄ŸXjD_/@A+
{1٪:}:Ō/aEXWP;dwtT{A_@Xk2pDhHh_d37^v$Kdbu9frw˷;[nώÆFĄ3H7_^ʔF܆fb`=7жKJHtt٘ȏE1BXoȏmy[{clLEҼʍR2[LCHDh'ʄHȄc&)=?6F<b+/%O/,K=UP=|%G@0S܌3.B01BxXG;fF`f!(0oFH	8xݍN9lh7Ex˒/)8/}t[~dhkt~CLJJPߖxwqD~2~&1L_oL@@,ĻNc0|H9Q>yc>tVS'_L|Io0FG+9'(=g0B@~L F9vdGB4y/Qt	R%˗3iP';L$OC5ziR4әJQMRa3
x׍UAA0 `xEH-05RQ"ޥ'G5ӯPYNGzO	7vrdD230vo96Yh_)W95H9c׶}wnXoظ瞍wr˙%zt17wqoOl|xʫ}ig$)bD߂Ʈ{+5=,^_4r#>^症#)Vе>zP \
У 8+4 M11G.|>	hȗ~%#)O*P((.To`x$w>钠g(?u#8+Р:;?@ӱ=k
?p}Ag*P @ԣF	rP^YTB[9.8}-1<+C~IGޭ᛼>?MN~QW
3UG&Lko\虹c0XjHWNV뙍#ވtCgclY#戁ލI'ތRY'"hk:Lv"HhwC5o	:
?vw<{q#ݜ=tC!xCzKwG6Mz-N|w~xBUGf	{ 0G
w#_cmߒ?d6/)b6/9b#}b⠅!J쓷 {H>-QHWՃEb>!ún7P~x
B	^Gh`o"մT1lYk,0ġ49yCp#XD#1[AD'XEӽt\/`K!I<YJ.%AaP°j d% L( UHF$)!cDX$>v.4CP i]")L.B/B#9ʒ婚MSX޵a2ԃGȥo6,ENQC3Yt@sVK59,8wNp@T:AйNtk!.~z;b3V	{Ц1YǬ
$[PW3d6%RSqb>堄T!e2TL$V0\	Xnd31Db TqdI`HUL)MavY?M\1Ke~RZǒx&>YB~jB%=ijMsKM
L^64qıF ’WXk2/
٤f%
28EPMoyWR5A4KPu&2RfBg ,q.eV2sU872Ybe(قZzs3}ں.4PO0Eyj@%aq%v-)K*uLHkF^Lþ"˶Tmuo(w.hREҢk1M-Yj0)=hHDf.gϸfV~v̟F*4Ƕk6A,Ќ-sdG#VDO{–׉l("#IY,
떶ٮڼ,P[%TL̢J3HeJ7Rݠ@JY"$Ԧ'cKSǠtD	TQxViZ@v
tCǐFIunb:i#آaC$)9=lgoFkvkcmkOԏ󑭒͸=s[N]o(_~{KہI8aݓ?()Aq<2ߋpD̫C.Ue+Nj<^r|~y
CBMnZXoNN=w7?֏t@2PH9'^Iuj=أ(v7#ԕڝs:΅̹]A;ov{;㈗	xݳ??zk]ί|Iq7fIIR_z׿֧'B{u~F&WQn_G2xKT}ⷿxJL?~d?q~co~W_3
o$P0Vo!oNN7:.(S𔲏_cPg#Zwe!$&PPp
p)(	po㘐"NP
0	M	߸]

U/
Y/a0
7aŏgo
)'0
	/,(GOP	
P7:(pXFO}
c7Uǥ
{n܁Q0<q:1qձ}Cq q
 Q74Q!n!yjl	r""w"Mdlـ>$5MGR$R%K.$u%K1&_n&s&osR'Y2{r~(r<)9)7*+,R,ǒ,,-R-ג-nQQ+6$Ŋ/R///r#.!U0S1112#S2'2+2+S.v.4CS4G4K43S7334_6cS6gRr55w6w7{7kSn7R8r9S89:S:::;S;0;;9Sm>6S?839@T@ATAAAB4?#BsoB+)C'ArCCCEDGTJDQDE4EYtECEaE=4FitFMt0UD]tGeGmGqTu4GyH}H4I#D4BtCÍ'rz(KyhKwKuKTtLLLŔ#4MMהLLMTM7M4NtNN4:"JQ" ;PKMYOOPK&AOEBPS/img/ccapp019.gif!IGIF89a			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~,	H*\ȰÇ#JHŋ3jȱǏ CIɓ(S\ɲ˗0cʜIͅ~Qϟ@
* |B?᳤Djʵ+A0^IYi!T˷/J 0~Ó?[Iң:'^ͺװc˞M۸s+T`>{8G+!K䉡%
'( 
CJӫ_Ͼ˗߻?GxGqSQ!W%hWA}cZͧv'bV$ןqNxjFu qrAS@; @G܈@2YDY=2U^`;8s?FxX[\ifH&KS #@)]y?Pl/mb]p
PC.IZX?@|@EbR+Qjj^DŽ:`>[2	ĞfȲ$l#--Nk-G^kv[Q:m:ngn+oҋuoL^|
sp2qVOUqbO̫"rɹL'.rjLsK3\:s@I?M-j$L7PGQHmXCME-&8d-dmvB۵7ͶCnrPoz+7~x
nA7͎?NP2ny/1).9E\zҙÌZҨ.m\W_> IB#pF:򑐌$!qIZ򒘔c62:蓠y8Q PVGTO6x9̤.w>.f&))bW?c	o%3z3WV{FfW-0My;f]ZЃJ[Ҙδ7iNk0ȹ5Y('3U(zQRzc%L.ϸ2/B-0 BNf;4$8(KaZmkz}s!ՂNq|dhhr;̐VsC
~ΖB;ψfȅvJ^B;͈X'vb0HF~/@b`E8u}Wrj@F2i?ù@^رQ
%#ֻ4bX)/&V!T)k5$0@`ILb5O(:_vE=~P
S"!E|mFZ!'%	G7'$(Q	S]UI@ߕ]72<Â|71Y\V]zHA*B|k$;H68_{9+
|H B-0O\wIÉ
Jmz}h.|wS(̯?g	g-7@QJy0Py2lg	h{rg@FzG}gX@ŧA|з'}`XYtl!]:EUQ
Ao@7]uaaY!F8*t	1u#&qz1~w$~(}x	18YQA[LāPwwVtHnE!3[VXXl8dx	f
aU!x=ZKVT}%M0aLqw!dojAQtd4W5]4)ބVEX"SFhPd굋J2a=WN]'UcR8v GG'5(҇(gnHE6"#eb&XhoANgjq?(yxW('XnOO&uPѨ^n@5mD{VIq\+!u$qr`TYV97V\ٕV	gihQTMG5GVrrpr8 YQQ22NjTX4#|W$!G(!1b$1I]'!!˜1ؙ(x\@Q %kՎDΖJH a	c]eiWfᆫ((vsHXnP*!Dw	nQRMVRXs0Bd1"n(XG@>i>y`i`줛WțfyPz:	`yTft͙oȞrY# Xi7!Ye?-Xf1d9=ZsQУ[^X	RSjxQ
Jw^9dZd*}	ن96D!ꖔ	2IiT1=qMh,VAvى=ɧdWViə|@#1ٓZ{r$8jaq(~c!Rُh	jq)&#ykmr!2b9b#&pA&U#2/lJ]t*!QݸAYh6gDﺓO	QrvT;`j(uŘܡFTH)n1Us!Q"+)Lj$FS8)ieD;N4o:mdNaLs"Ku(:[":pqv{Yk"$ dU ʬ!E"#!,r;t1Ph{\[PpuU(Y;ayn+R)yd({ѷ\q.A?Ѹ!񸐫	%a[-+oKv@kk{qr,7 t{[V	kJlQ%DU&
'frK+kg3HYq!A+{	{SQBN7%'PP۳:hs%[z@Da) ==v!L1_qLfW*MR3\;6LX<qaVMבg1d)"VE1}"%pR"?;DM5,dEo1d6B=4ïuF&Kk+Lx	#'i!:Q{>iI:jqAOM6%9#8Mai@'_)=[BpwkJ"P_rAPK§>;n'ջ?ڊMBqɬl&{Ɋ|j8R$Qws+}ȇXȸNMk5(UqA"thE)<)qqSQ<EXas)f܆
?,бr
B>?	?,dK` <d"Q	"&ͱ}m	Љ?ÒMQu#7iѓBC܆qa0!H."^Pp`* q?]A
RGq=mCC-%,+ǟw̭ءӄ
0ۧ1ɏ-Xx<#?DZ=d;SA#ݭh|]
آbu;ce}?PM?8ʼ9m,Dc>,l[]bj$^^)}
H֝:a!m)L;=q{["%m;oD;UGF/ZҸvshFM^?Z%Ne;#ڍ-t}#)
^HF@N
PC.6Wbk>;d;p޺!4'
n*1#ѰJ
^a>2I
.%J~P#nn'@)ZZ!'!6Qtͽ.}^[~^NN
z;^!YA12.@
P
)N^^Nlނ/Cٌ1{n
gX
&?o'gߥOKOo
pJ.02?4Sz*N^8LO|w

~0.^GI:
b?$C1X_N}n__a??f1WY߶[ms
@#QAx|lMѷ
@"a@Cvs&Uy߾=ףOx
! sO}?Ŀg >> l~$.}/OoOx
o26

$XBC%"E"@El`N9HvbKKs1eΤYM2_ʧ@
#ZQIgP!ÂCNZj҃
һի|7t,уA
=۶&QSc˝_Аәbcȑ%tœ5o9r֊y&]t:
2ݚqY͙Wܓ)uo'jJu{i7٫-8vvɂס\ݻ--{†a!V>z},C{p@rztA#p	XC6P+/b#?<=Zt7bE
O|C1F $)źHdE$`F3QHpr\G(2@$nk2δJ5;RH-یHYN5A@`\((I!l6`b{mKzQn#"LA"D cc.4hkt26h@fƀ wci\(5Jf#$;(alU@EFjnH:$yIa&ǁtғ4$*it"~( v72R$F+6RM\I-iuK)	aAb@T0D!X"M04C3YsK1LR0"g9x&tnIVbH	.xN9aNJR?=OyxdfE#ǓcdbP(9#%DMpt0:2Q(tJ HMaqsM%(d>2MdSn&mO	h#^DceB:0 PS]5GYNmӕHѹfow$gv9d깡uFW4D8nS+E7xalㄋf.c8oK1M6H7t;]"H@sL=!@uKyՓ
5= v}N`_~wCw{n|
?˽g|Jw.|!E|=yЇ^'}Mzԧ^g}]z;l{^}}{_'~|'_g~=~}g_~}_'~_5_E_@@,@<L+l@|@@	@
@T@@@,A>>;;;   sss000vvvPPPpppސ```<<<߲￯JJJooo//&666__L&&&ϥ,,,XXXۏrgggooY///ᔔ:::999777ӏՅOO?___555uuuOOO


rrriiiÉ]]]lllbbbwww}}}mmm'''NNNŊfff444SSS{{{kkk888!!!+++dddtttnnn\\\---CCCMMMRRR333AAAɘZZZTTTYYY~~~Ă***BBBKKK[[[222ccc!,s}	H*\ȰÇ#JHŋ3jȱǏ CIɓ(SD@(I͛8K 1 H`b@r*]ʴӒ4
Ta	20ӯ`ỀQ@,Sv`]K](bI{Èxq" 5˘^XAbىgMJ#E+M6mNŅ&%p2eȓ+?h?>`ʼn(h׾Oӫ_Ͼdf_e1ˀ2
LOBQ*	-c BEgX!y
.E(TC	de\h@+@XL РbP| v%c䑎 0J+DU pcK7(
 dBA
egf%l*ւ4#9)g
O9
s&Cj.D؉
#Ac.2
ڵ&턤#0 cꩨ|E
Jđ@ÚUYRP`kn4LnaZ*LfAf,|0Fye`n(v8l3,#N6/κnF&n+ڲ
g
gUOXEYHT[	ng
OL0c<IŇn<(w*rH'*T$AGTP@Jg(aR}SvUS-6)m2#l^eH|eBjk[u#$)$Sp-0F_bG"ÂrN@I5pӺ6da*6Eoifkѡ|`aN(8O޽.lC]DHI앿?@2~65dܯjTW
~CںG'I#h
"4C'	@9 Pb?G$6ےn~4BGYٷN|@(E3GʈG4@K߸fӪӬJx-nSy&t#-Õ
ʲ{T`a숴-
@võ(/21hJba\	>2?rwIxH{e2F0N0jLpi,<'L'$ LhP,Xq!
08qH0DLQZ0.$>niUJJWRFtl(#e4$Ia늁
j\
Q@t
iqSdx;U y, XͪV$rbL`,զQ\2,PTYpݪW!*
D2ΠjꏐKBYZzk\'H+׾δ+rhGKڦ.֡Xc9*buRlg&òY5t6}iK9%Mm&^ϵXR[VX-7up"%\4vj5SAWԵ-n-rp67Q2F&d_22{+	ܡ	Uh-H4d`]jH&0!"aGq!	G!x 06nWo7rjط3C.;fH^'܌b Qd=PO12(	N."S9.аIp\ qB=f*0	tD=9zF
Б"\64/g	$=bĆ/Xg,#HHطCr~NDӛNל/ԛLc8ɘO@CM&7!@ #e9j- 1(ِi
Fȶ
/e9"ӂwZY0o|z(ʫKW:HvA"PBe q;|J`QƉԧNK 	uq{[-,(L8Ʒ]|H#yGzcà@&B*O|q|"d3('O[ϼ7{Mq|'ԣ5u@Qd'Oo20ي"B%`dT@`
TE
(q[IϾ{P{29#2O/?DূYJh6JpW8
PFFtʻ0驉a˹pˬqf!sjצEl*j$j}Z;wȏ_'Yk1_+K{${s8P2ؗ:~5xfoxwy׋}w
dm!B+ԙFŻ+'|W<ZHb7d1@5	(p)xEwL'z˺滏G+ň;TW̞![\<Ţثۦ+2:0kwzg#iX]B'1h2ʠ@PO\Ю~L@@0@9Wˌ~L@POsl>\13n賞È~V軮~^.Q
P~؞ھ>nun|Ptxu	6#x.Nxܺ鿮.?_d^mZ$_&Ooܓۧ)P68:<>@<0
4_
2quAJ>POUYfU(HLd].0cjbx?э_
ne+?^}Z][NC?.n.A9S8KOw\>Y|oq$?_ ?AM *r0⿵@y
Þ^GO"$2P @	0HPA	.<(?$NXE4nG!E$YI)Udْ$dRI&a38hЀ
dڴÈNUYn5$&j9C
Xu	%qe
A=T !Cj"dJjYd5ŕ@Se
Xe$FǜNAA =(DL*"sTRKO1,4UpcM4iM(.1D)X
*{CyB@	.\PTH`c
f$bf@x]v1
Ivia!t︃?E
IđN0$b!-2xd8-jv
pb̾Hcp(B2krh-@o3‰r"i8*hZs؟;PK%PK&AOEBPS/img/ccapp010.gif'@GIF89a			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~,	H*\ȰÇ#JHŋ3jȱǏ CIɓ(S\ɲ˗0cʜIͅ~Qϟ@
* |B?᳤Djʵ+A0^IYi!T˷/J 0~Ó?[Iң:'^ͺװc˞M۸s+T`>{8G+!K䉡%
'( 
CJӫ_Ͼ˗߻?GxGqSQ!W%hWA}cZͧv'bV$ןqNxjFu qrAS@; @G܈@2YDY=2U^`;8s?FxX[\ifH&KS #@)]y?Pl/mb]p
PC.IZX?@|@EbR+Qjj^DŽ:`>[2	ĞfȲ$l#--Nk-G^kv[Q:m:ngn+oҋuoL^|
sp2qVOUqbO̫"rɹL'.rjLsK3\:s@I?M-j$L7PGQHmXCME-&8d-dmvB۵7ͶCnrPoz+7~x
nA7͎?NP2ny/1).9E\zҙÌZҨ.m\W_P>񏀔
pBFTJZ0N(GQqp<$Br[8+upP៱Zn2_-OG?x#~?NJSq-,F }j!6{z.R|PT'F?sQqTy~Tɐ^ܬJ[R\S@4͏ Sk՞Bei9\}jRTJ.IR<8ox
rWkeUOUvI%29)=7N]xR3!U=HwCcyz8p"
lP:-jdJP[0&
la*:D~LA4=v %)̱Z5ll$GE\2Zo"OgwRV1fIwX4t}VtZTXw+'NjEe)9lv?%\ywn'sUaB2klQ%(:V?åO.Rkw1lɵXx&N9iq$at@.Ժ)sZ)5O[dEYS>,o
-πMBhco*)ILFXq4iь鰼cǢ?CH#vby{.l!Zָεwk^'ziN}0F-Mrʱ:?}09O4WPj+=jW8N`MW
uv
a<#&)bE
4`1g.3#E{묋|a;s0w-0uȸ7N
w{HF2'|'+jY5ĕ4\lZ3-[RM"v9 @k߇_mkznXW0$&1	k]p6}bO"_\)uz%/kof@dNýrD%^Rtu)5;bϵߨSwN+V1uu#e-ۊRpwPחwfAI=őR90OԾ6i8}PުGPvKns
v/~"0yP!~}uW]ttj00{:{ {W	(U|aWAFtESAq;@&[+9I2\A'7Gkl@pWM:Gx	&HuPā\05f4xdA>^k Yk}8K(M8}v)8XxkZx	\
a0tt1Y6VQ[L0"ц|Fv!qcodj1sd4pV\4)U0j)uFl$MoQ"Jzx.yuUQFH
PQ긎v Gsj8爏b_HE6"#erdďg`F	7'$fofNfՃ&uM
tA6XNQEKMq^qPA{'气LٔsvsДR9Tٔx	ЅdJe#}$`$SIG\eYdTbL|H%#ϤFipy59'qJr4r&Mu_yvr(H(Z{@dP %TUDvJ:tXX	Z)_h0uٙDxǹhؖN# pWnP* GZkZ`)S"KM1UGHr0bu`_qWrI@TJcj1MiIkph			Q_5u/GQA`Ȝ	wupyY`OYaLӣEw"	Ay#K!>9e1aAZIYXZ'Лa#HiNajFI'P 
2PvMu2WTɞ[d@Ӄ1}YF{r$/jqq(scGiV]	_J=yp{mjlBTM&/,3!#6l
'tZNٙ9	xꛠh{9QHqA%GyQo*F)]
|z-ƂT;plщQGjrԉL5*grcE)(YrыH"Y:WL4	l$Mx+!Ir/ˊU$
7IT+o8SX"$dcy,ƴ
axJ(Lv!Xf{t\kP@tU@^ⶵ}!AE~({]/? !z	۶ۭ[.'ؠk6'a{I|	`vS+%U&
&k;}e|E{X	7Q!M %'P۾++ܫ
彤+k狫	DR%C=c'Djqӱ&"лDdSW*M1OLd(V1`oTJV#"E1#ASG!%ӿSN4tnd6B=0ism:jqANL(%9#8L`;ZBY`"%d<ʡDJ4s*|*SprcYeBq8QW\;TɽLkd˻lrv>`MҶX
|
6K)-⛙xrGۭ%\uW)F3MZ7NMRlDCA\Cהj6ץךku
SHF7K
!S:b1j5;Tp
w 
xn[%1KIW>so]!^0$N[|>[n'
0
zM1L<|֒|N0..ҙnO@
P'[QYl5]5|P
]D%QnkϜ |ھ̮Vk~Y`C?T'a
vOuP?CZDe`
`BJ&(*,*P^!r(|V>5
7O9O{'pI?K?M<>?RvTV[1OC^
|
"A7鈯

|~_a/ce_  ｗ?Ů
i&ޮ;/~0Nv|
>^퇟?
?Q7q7yq

o2Ott.

?$X!dC)W_DؒG!E$Y$Ȏb)P!CzdΤYM9%ZA @3ԩSz8U	+Qo'V,w1YSc[qmrW.Lg_&ljOK/f1aJN{\ٲuٳ_?vK,EhUTkرeϦo/W~'o#'|sຑ/865skO^#BIJ#ؓMga`^j}. `t>RoWP>O#r\
`gZ1
Ds蠟Ÿճu:} Sh@Y:r7D
+P.7Œ-s0QSܳm [27fu[J-÷ZIvdJwSd;
1HQ !ϢZ'?
Е3+CdUmTRf	g說*kUxuxRI7X9%MBb+.kKFTK1a~=z,"ɞ4:$|͢PIV6+1ZGn[6!:;Lj..r1Fm8wU΃=onmpd û+#&ǼB/bkH|SݷDt']&W
p##Rd%].`qauD6~S5@Jحe80;DՄ8F9ȴ%GSQyrVviD巙ԋsTR07Vi%Kl](O̠sy^Z3ܔ{2σJ<B]I6e-mfdZ!!$F-dr4'-
pƦgjn~AF˨Xjsv/[Me@i9"b>:mf7׮$(;#Ȏ[]ˣ6]hP["
mXX&kBC^Ml5T&7jo6F4oGEp<wGq^G#8[%-w6)5>#fK3IO_Wq|‹$\[:7s}BW/SkL(9`ٍr-Mkg{ۙu+|LG_؍8g'A>4
'|
x'^OxȯհFaEg^<Q^'}M{zg=z4eO{ܗ<ΐ_'~?r]5_y>|C?}>~_5ݾ{H߿G~(~u~}e*7pn(@<@Ll@op@	@	?ҿ?{S"nj@J=»?
A;yx_xAGRATgpA$Gހt
G8t.2ByxP-%C?D,fkDENP6/C0ܢLMDOPE5 748?ܢUlOBE7/|T\EWEAEK,EZ
SB}A=TO2TEDmmTHGTbTK=JTNMT
TQMP-UN#UTS]UߋGW-VթaNaр;PKl''PK&AOEBPS/img/pethilitb.gifGIF89a@PַΙ)czhR狛֜utsZs0mKXiks`krtk9BRppJBRb@rBs͕J{c{k1Ό&./W	/"15Ë"WI
H*\ȰÇk6QDy/扸+χɓ%O\ɲ˗0cʜI͛8sɳϟ@
JOH*]ʴӧPJJիXjUc$ʮ6^R^qD۷pʝKݻxjYŰkI]̸ǐ#KL2ݿfk>s6jIֲӨS^ͺj+ȞMVͻ܌vN;IgѢCF	УKNسkνËOӫ_Ϟ:l+I++}g 0j'D([HXfI '@'h(,0(xX! 8
ߎ<7_wH78H=F	N	bhGa }2dihlI#<*i#rGv9$@)T&n]z	b
"If馜v駠b@>_/6I8J}*Teb+n@Ci&&6ЎzjҚwuV~`{+(?̿s,׺n~?΀i<d] @y;Z9aڭDijso6V2Vh@9(aAN>\ |#O6pler1b	@nb`#4Frn6:elw<>W@F
LdvB8'ڙ?Jt$&U0d;ݑJ34n("Ols^ PVBdItBEM6{vIrPA}MT@de ~<?8hH&Й@6Mmz
&	O64%lȧͦft@N9B24)NuJ13DrZ4ծN5Sumrֿ u6T:RHC,I1nwiwX>
MyMdӪI8&%	.tTJCЧyJ(hX-
c#!\0Lp`ϧҔ x-&̍7g^
\F\w6(,vtzn]ewXL|iΆ_gȷr,{˛7jMxkfX˲F5/o~]Ggߚ&s[Z6fJc>ϪhЌkBR-k[{1(p۔'p P6@ҲPXx{bq+b2vtfi)`lm-@͘R|e`s!|ۛ2V0gz{G̃Nsoؼhل.¶	ola7[8^TϦuA`ӷv|IvL(PnH0AWła1{u%RⰵeK[9@p%t8ȽqXz-K9be05^֠$3;.]fa>Me֛z^[7DAK!9L^q<9/S|pwq<շ]{˜):EpcΊ7UWK^ߢ?.p&} r[QDrX\{_'Z欏lʸ>h$ jn[3X2yʋ`po&ur+[4`B:`p[,;37H%n"xA\gVkέ}_'vO߷>Yu7ߥ9O9g=
9쬽{*G`=7ouU5Wzg^MIG]U~hqA~|w',Y0l$Hx!-4*"cPWPZ(X!G.aJcy6 "w=HTP&iKzgz~Rv\=|#~6== z!>ӅSM_e4p'>[Hb
|p{bt9+bX}VGyHU{hqngg]}?MGTh~?gUF(?8煶SjŁ=@no`3zCweȄq󖈹AiԁD.lQc+/!xR! QƒR`SvGxgNxFTw9:>8Gxpkw_qedKwF%6E#r[džwthswi%=F|Tzאp$dX}tz…Nx`Еg
&Ov68h#|!sV^G/!&1l6FIPyIYG1V9Rm5CFyr18Par
FKq@vFxiXMdVSa+0p$r}ZvycghsUnbuXp}`x؆Ҕ}9gLX+fooWnƘG'?w}ɘy	S#o~kyE:~kEka@sٔx1F+8lYɂ9֕!WpCBECeYJu1".=sItOff''>E
R{(p”qg9 L
 g ?:08>E@>!.#ŧ`S`.*q1T@C
G@4ڣK;:Fh`pLJX*LDf'4<%4SZ\
#45ȗ! y\5p/Z Ix3p.2=B+Y$ZɕJS٨ "d3CZP!ࢵ%Rp_(eʣ*eT+:)Pǥ8E	/%p0qpuazXƺ? LJG8]
Һz$ʫ媮@9s4C:zjuApU܇mHJa	K* $4j{80(W!c@-:x(+' dة_^2I7 U`!	jӤ$g**	M:"!"zǗ몵>]k_;5.YwsڶvʫjJ>kzk$jZaNJ[g[Ҫ•u۷y,L+\N+va*s۸\sq0QxBFc'Ҟ3K֦5©v<_@"ʹN	EJ9cֺP[	@jGMz{»7^{r{03Tj;++E3
`+يC	]J/|l4U
y$µAr;gì@Kë.4H|{%1kgҼϛ˳ʶPpKƎƌ@K=Ÿ٘`Əºy翡orwK!e{\	Z0Ȅkȍw	|LmKzɕ\yɋɏlʔKdK"cwʳlZȌPMKĹƣqLˎsʢ,ǰ|J
CI&;T+ŻMI\iś	][@y꼹P`,TQ[|ܷ\}В!,RG\Њ	<41L[	=pό/*,.0Ғq.=8:<ӎR .یѺ*H-[ƪ#˟b,1^`==jz-Mf-jlnpI'M5<t GLc׫Zխ\\Y(-r]ٖ}Zq6nFaҚٻ٘]ڦ}ڨڪBr8'#) ml]m".[ج؏rXm[-=n:mԝڽUap5]}!Z#w`-V9nݼ0: ِ
n8ζnᴁna;(*,p̢@?0<˟< 5>@B>D^F~HJLNPR>T^V~XZ\^g!fnɟ:lnpr>t^v~xz|~>^~舞._/$Q >^~阞难>^~ꨞ^M.^~븞뺾>^~Ȟʾ>^~N>^~h??/Y ">*,.0ϳE@?@Ξ;BE=~@N^7o)9ZXŞ[C/`N!0lO@eN[/}/D/cOeNNuJnP>Tw_OB@N^$pOLюo쬏?9/ao%O'WNnL>E?@QBS0OaE)15!=1/DŽ̂L!φҘԠdjk,Dl>H @>UC-D~Z6}д		TNad)&ԜQH(mm븓c+zWPTF.Q02d8Z>sc=3z $Dvl`Tҧp`+&w-\fuV9r!&u^ 	ayku21x~
@JЂMBІ:V@ъZTͨF7юz 
HGJҒ(MJWҖ0LgJӚ8ͩNwSo,PJԢu>}U!zԦ:PfRժZXTծzQ]a];Sf|>%S9|_/4W{qc7:ا,u4N\Ч>~}٪Ys<`GD;Џ~++_lCx ~OxcYDa	5F7{^jhO~Zgf~>W'zV7c;`+z&JHo(\xe7zXhz]wm|	V6x8:Rsׇ}5ۧt5} W%gmr~Hpr'b>2W'0h:VQ{W3Nz+N6X W>fSk;H%4wNmhuou8DwBVF;Xx.Ճ/@]r(VE8bZ(4~4WwEYjzT/xY;Pcl3&ŅW,_`;NXQTf70d3{/$*ci`(V8}e0vfIǍXELjwBH(9;ȉ,牟xPB8xNdnXo5~xi6dž~Vc@U*/gl-]2ya#p^C'WEeS293i^PocXZ`Dk:YKhQ-`BgGNU	IN	a)Z6`QK0YvyxR=Nib	O3^pjFmk&d0xtXO8T9sl9ĸat6kD	OI5kjNГ~|IkM7t7lTCgef^7 6~`IaYEs^ٛpQy	eQ{I})h94	4T閍'Yki!VEhpUjȈɖg^'aHPwj
В	I W=yaVr׹in)^؛յz	HQ9)JlȢDyB,Hu^35KPQq9RҰSQYJ`W*S[]Q_*a_eZQgQqǗ$ dၟex:O	x*rgl`R7	CVwO١CYFu=QV<&بlI*
ucؤli:PSf\aA:D[ZaLjN3_RJRiJQe:Ҫf+*czS݊pJ&u1Sݪ
ʮ՞Cbpy0įPC{*O}ک̊IYuFl709D*
`:9@vQJkVfX骰jO@#6갢;cqKd)_ݦt6~d1˪Q:U eV**QiRikQafR%eﺞڦNi\@Q$蠟PKO	Z˪U70]˰ˠ	֒3𠗊rzg\ WZrP\ZQV+ں -(O9L:&Ȼ,
Zp_XzLxhݦ{و[ 7]{RWzqQ:;h;]ʾZY*+n;{r;<kQi۾
̿<[l_K
x{[%@Pd5Nk0E0p;‡ޫj+jNm@)N0QK #+ƶĬ=HzUQvV6^2\KzhXBXV;YgPo`h\I1&ŀ&x|l9Isœ%]	^,Kʸ¸lQ+˹<J
̭¼`{|L<¨|ͭ|(܃Cv<2N ڐD@g@AB
0 H<fElİ{X
VOŹA@{PKKa)ױV$e,'hDƼ[u@@l*|5]4q]5b=7t89~ٵdLm%ZԘNGiu<^|ԔЮ\QL̽ݼZJ̮xq=׫|nЌlyoʩLnMqZl
 i07WO8@\B <Ұ$xKtmdMgZ[A
@mzվaDZ95V*]>K1zp7ev\bXݺhȔ~ZDͤ6c,S6^-@Sɔގ߿MfimfkʕˋpˤĿ\m,L2
l.l8ؓ\וٜEΣ7Tv`mБ}۪MwLa΋/KG{Ip+ޭxbm^ kƘr+xVf~
~nQ=%~奋=ߴ}z-r߷h>n9Bf閹c#Թlcm梜Q^PnA׾4><@^쑍,;2N׿9>ՎG.ۗP)ivP)O;LAB,#9`_I;p30K\+kNMK[,WF^!yu&POl,@YIKke},kANm)OX+|Ϧ
Ԓha^e|Z7jRz)nN0n|Ծ]]A؂qoNz,XNNU`[n@$Sp<{` mOgT
^b,6c݇ƱY{^Sn?3?YcHNO+c;VlNmǟZM_OB5_+wθj&y<ivnnbl9CQ9^gSC0KDX
7*F|#T1^
2fD"$cT$wѨ1RİGRO7T:2JlXt
,yY#DL+
.) hVXB8S5f+QF*U@װsyW &^7͒ؑŘ7BeǦ`=2͊gIvU3gОHcfĬ=gn}yڧ(e7j܉Q	'}iqJtƣ'V37eH[gMLyccZmᬭ8׮8Esp"@(XሑzFI
 QI+e4`!RFL5ݔK'7yqS	E_<
\5^zy
7w1z"~-Ebq8Lv(W(`",䓪g&PVYelOb	\v_)YN%\rGUD'lM0SY4ۀMx=uʎ;3\`h}S'K#@I($R`3!M60EBvNKAzaK!ڪ#9Ϭ#cmmQIc2#E;0=$Rdzʒbi9)IlֳKiDQKlVjC-X@$
+2j:#FN<#.@)RLLd6iJ˲˺鳭:w=SxI	$(Uo~CA:>&q*?CFR:e/r\	
̠7A0GH(!<ɭu#[rմyD
H!C$@@;%>p曔^8GG#JgO#9-D?YQ`i
`6pH:x̣>  `?L"F:򑐌d#!0\ȈcT~Tz|	¾-\TT0iH~b2Qė0IbL2f:Ќ4IjZh!6Y#Yyd&S\0Ni|RhH%
!~y6zSLcMBІ:D'JъZͨF7юzt
)?&Ro((J}')$nz%ͩNFҝ@
PJԢU==)ĩIN3j$׾
`KMb:ְ-(k@ZͬeΨҞMjWֺlgKͭnw
pKִ:Y:ЍtKZͮvz7nIl!`Mz|K׸\	L~_;'La+؈
p+{ }taSfإEj
0gLcؿ@b5L"Yp,~1,W֠l@T E!
BE-sYY]9_/3N՜<4'rsX`9;ƪj)ey$G8?@/ІM)t0m(Ѹ4}AtৣGi,A	JmSв7Mk;СG]h&C`L]fɮu]+֏-lSҖ-4ڛNhNϥOp6%X-sAG\-E^BS9ȵn6Sbe-y{>CKq\,`@@f֔8ClC[Gyrdd:e:WXGNjr\>ͫ{<u߾`=e/|]@~%&ɳ:ޓY}8?/ĿeDgh۰r%"7z7Ԑjgfj7
6
nju6W|}l+&VwBk+ǀWk8i6 6`WguGh;@$n=i F4Jv%}Vu8@I
&WmrhiHtcx(Q8vQa؆Ɓ(\Hho/AFm&8]HNG9jfzv\g(o@CknUR/D?j!CQ;`- )>F̘>q3 ekFQ @ȋ(6UP!w`pj؍8kڈȍRxj؈ϸ `h`縌v?!@	hɏ؍%R+؍(X%)>+y@`ؒ(ɌPPs;Y*iK8ᰐI<ٓy縓&xXdӸnIٍSI<@ɒpIisH?		9K9ᰕvCYhhUٌ-ymI*S9䠐(gc٘2I(TsYle
w[i0p-h4;0Yx+ٚɜ8XhMFqki)h(4+Y(ɖ[R`K`M&)%9 	>RAde_	`390͘9`%:vo٠xBI3=٢*ʡz?KFI[)/*؟Se9g:ͩ	J;
Z<
ٝɓiP?K? A^)TʖojTjyةIY+slyI
"
'Qة7*Z֘+*Y^0IBy@ڤnʣOڝࠋXP`
:[٪Wڤy᠌zF`Êh*𤋮̊i*?a/oڣoJJ:*H`jʥ/%3@z#Zh+yHyh"ʭJkjͪ>ȌDЛZ+G >Ѧ!٨ש_:cqC@Q`>ڰݨ+	]mcf&[y*:E۵ z_
XDʐyR؈
?МXVkDkḸ暖
+t+aɡcl;əӨҶi؏YYwpjAy> ;{){z}4[q7Sꥇd&)0/LദɌY䋾HC;[9@dۿ+Ay
ѿjz:Z;/u>aj&I竭, |I|dQb{Y*|*{cK䉖|Siæ|IaZ[+_)_!,Z[+IAck89?p̟̌Ȋl|	SN+ȡďʨgg<ʥLMj)%JɑȺ,ʪ˩Ƚs)ɐ˽ȣk+J9
),̺̯\R8<	͑ʬ٬Q0ͰfK鼪䌗Hy̐Լʭ"|ϻ<2LS$ͼ,\?A
mб\[<~,v1 ʦtIA-C}Яz]CՌ`-m͇ksƼv̘ IhlM|1Jj
7טͮhؘU?BI؋ޘ/ѥ|п
׬}ԕ
T\Z=M]x=lݘnv=Ă}}w{NJZ>f4sdK
U]k`
`h}b}XMыnOY\K0&ը۔P=ݑ[@(
~L͔=+nR-ٌ8pd/5͐ N9M阞階ћ%%E/Nɦꪾ^H~ع{L߻.£>~ȞnN֋~؞ھ,h~ݞ_Ԏ5^~nf?_
?_ "?$_&(Oy
@	$40//<0^P!#DA55.50]!F%@95Ro%>o[G	]&@2+L5[;c?/o?5ɴHzq;
a_%?]#YPo%_%25%~^"k?+YhYa$/$O	<ɯ5{?pUcQ%?Z\#=WB?DipRX+
!.2džɬ٦ŖʿÖ.Њץ8yJ)M*$\tJh([I{L/jLȳpfS /2:oкc/l]Pv3͏v3+;|棐6XdUvjhfIpUQE4
Ǟj2m/{wW
;QPԝ݆vIZ'H.H-~RBc9
n,ڤ=Pӈ(wK!z}ߖM:z	NO3
U#,wL	7B_cu.wkoo uOoz^ϮH:?\#]6/\5J7o(V?AD*1Y0UMucJ0!h]i]6EqKw
A_~A
~ǃ74X_B.W4]cpC&.9"/LyBGxǺUXDB%WKdX
8ye!Fhn/0́Q"ǥ%x}YDH4rm,H#m?]Q
=i|A$#_z`0Rd`XX,ɢÁc(;t
~@2zGjN,&ۚ4UobY4D{	T4%lgyDi9Eu;F(̈́r9$Hʗse?];-
aKK-Sf\,BS&S^qMjJApCz.LFՍPNg8տN#wQ"þA#_wpw\H'ƶճ3DjDj^j#qQDxTU"\6L(koa7\TAbӣvrܗrv\"B"\D䈶,RVO.]S-]	==TPp^(TY|7%u:S
WU(WfA{o$(;Ye[ay+ӀMqӚ~0jލv/;Y"zq	+%"uR㡸$]kHT@G^E!<{mIMJ;<E/?,
QBejj^DtDTm]51 Ə|wؙ|^gKNM,l@&5ސ5y|fE0/^u_̫}ϼc@`=OuZٷ6ֻ@~쩧5.^5oz?~VЏ>ލl1Ͼ
"KoO>/~_ϿvW^
؀}~x؁8~Xu&x(*'!8~H|EKw~Ex%v9~6X}
4{?}EV^wj''"y=8^#UC~#h~qDŽwAv`Fbvx煓Y-}lXlU(s(vn
pnW]36~~.YR#HH{uW{_e9WwzxƂu_yx6y'1 1z
D(vzavyDwx6@w%h-ĨNNjxhyuv͸xx-f݃xXvl(^׊xո5ecX\YDD.0u	47
qtKO)&XW]V5lFjؑhj(MoqWo
(3@kn>1&?K	;Lwh
y֘\D9afH
[
9[)s5{1HQ*`8l=Yw8(!$UuG#< wciSGA"R_[r&'2&EPa FL;d][f90j<^~$@ţ>6uL+zZ:&r@rSuD!⣥J*٪FZ.IR9[DHK`\E'E(4Y+xD1Dis_MsbǶBGm'KI#!G	4N[UA|kvZw5.0MhY%F#Yеb>HFO+$'-%e*-8vN%Z1 TD{MM@˵;57tr;UԮLQ^v;jE
R~[R.kMļkTOwjJVgu UXYl5C[ӵ1]13\8Z\C؅ћ裪Wve*+]\%<:G"ueY>N]+ AhWV-<[I$CJWW”}ة_fIffR_?vldcf0v(\$mtRfaDDO&%0N:|g
d:PmlCàgqZ2ʊ|hۖh5qEff9Fd4Ȯ|YhV2h˾	_`^˾m]ɏƄh2fJb;:ȎHɌ̗ʭbdlǓl%wp6fqp7nu/pXF0g<$7D=lE 7q6GѲpHqF`o=7 sdt:gs
.=tQll!j	/q5TVm+pjaLUL[jlkYԠMmw<6?Ewk!yȅo_ѧ[ 
,lk7g֊wp,$x~v񈎌؛8vjL˗+se`y,%uئ-;'׍X؜wjxQ=}Qχ=5m]ڽX==]͊lZx]}݂YYy(yjwvy8dU̓
v~|B|;@=NTqpwTie7veug7:{=1^8}2'hE	4
M=Nˎ|{xvaK^cubv՟rug(>^}wxquu@߿x>2+ܜwxzGWWgv(~諜}wws>xv>^yNܷ߫M5m}>{+Szxov@7~x~.HN~)
4#ڔK|9K%ۀUԑg32akyl^ЋbdE'4QRŴs,u2IFNҹd/s^<vkTj.Vג)./
^vJK!ppI9kR3iL Rq2i>sA*Ÿ!R+u9#8'j	c"sOx[zi
P%(qon"᜵Ie`p
x:$b$ǞbQO,?#yXi#_=Z	Fji46&'GPt=O`N"?M.Oup%SkQc55
 
*+2(.!̊ΑȊſܚå෧ϣڲЕĀF"v&hY.aνj#LΕ+S'?t(`!IUa(R?>c82N
B8eĮZm	[Kkzٳ+
]@)b#Ƌf3
LE%*SS"S\^=\p'-?^ٱ*Y3Q )o5]\HyiclӜẗ́VYWF
Y3D׋?5ޝ	ݑE,uwldBPsGtqͮvizFՍ[[Mo^dV
ng	]J}߼ͥ&ƬN0lǹ&׵X\fFWf7c7
S:=
y8m`gL8αw	屐L"HNrv[aYPL*[/VE{.{`dYcN69Ynі}C^H;Ϭ5,tKk* &P-WUuilbfv27?zo}oq[^Ye6mҮ^/s[Jk<-iFHhaٝ.5lnҵn8ྎ5ھS
ۻpS{q6|?M[y7+u=&9NZ?8D$IG:-OgZgk
X*3&c<3Z&<@,cm^5zhA;>wŜI~;y잤]Tq*8	;^YywCf#Y6j=5dv`ZTu_Oy*^,-nRyx>1x/Фf@E3?oYyC
b=
yBeXG)wB~߻:7Xd6ol1g/4
00>Y{-~*`0_EǐO
"8
 /c{J7iM=`Kx؁tYu;
Ȁð%	R6ȁ\S'HSՄ@x2.I=G[a@3-%Pjvdž>ʣo,Āt1R-H"
L8W!ӈ7xgYYpbwL!	SoMUQ
8VeN@@S!`d5!gԁCIS,M=V#a	2QSEd(P!=$Hbt
qT"GEQ0|mO/A`ɔ@{X"
-F2X!m26p"a7HCn|/XS&	buBGjTZXV*P)m;{,6R $%2$K(K01,q2&2	<ٗ	FTr)R)RbYD&:M)>r&GB'&b,_x guܡ ?y@١B%	/j?:,2E&z!ɚzLT6+LW0_+823(%U㬺es5=tYJȊm93YĬ[%Hɧ'$
&A;5Ġ"*IX7쪰ʭ8zFk$Ԫ6!;۪|KrіIP[U!(A>{IĦKqE94IA
G?D)TQȖ;kGCE'{)WN̽XEaxaWd4T~=wT@B̜PcvEt_Ƶ\[^jZ|_8&e)'5WǮr<ůza]`M@y@#z'd]iw{Y{R {|Q6n;}3(;"M{:踃\{	ڠS&!Xׄ?U<;]Ys:&}֬ɓʏVͳaXČXi82d6Mi‘4L2LT-mqϱUd5vЗCb"(&T)٪䭛15&ގS	ֻ-E֙Z
Nӯ
bC
-.ɒ'Z*Y#:6	.*k+3J+u2O⼱ݰt*/9/xZJkK(#C]]5knVb>8=wزszvʱڀ1֍V>?K<'*Њ]6WN*J
s~3N
~B~[%n9IaaMEklw(&gUg{X-˥*oI@*)9®e=R,vHÔER!VlVnWd쌑Wa5i?(,	:l/VS#Y><n|fɵ5^$]l[u"f_ 
ȅZo_n%`nlj#U_*]˲\&?o	O8:Ж7@B()?H8_죬JP_6Q_V(rW\S]boYch_oinLNt_\^lz}|_s?bek?/d__f/b~/ס_`5~ETJM_?uo_E>5(]<%i60av-
	}b+

Y!.)16!=1/2*ܢ+8+(+K?
1hAc%[YiYp*E|9HS]cISL_)kp+V$ɡ$D*fL9ZNXF9&fC*j('/Tiٴۖz%l-$WSߡJ{Pೆx2&rYk.c$A᜘$Ҝ%
rعdhtPE/jU"_j~#}܇U.#8%qDVu7!
.<hl_@W}Ҽm<]:+7vxM>Zf0tt|S^h'^(Jlbq8~Vv@񅢊gSb7)h[zxh[w톢i"c"L'.UWڅ8x('f"V5cqґǭOBȕ
\c8-$PFf+ft؜bP(0@YサeI	a4ٌZ=͵?]5[6-Bh~g}[{Ba]e-rK8ߕֹtvoꠊb>[1#06c.rl.{+dOxێN-eL0XV,%.&8M|pt8/	p3B~IPC=}:Z]	ԾEr3Vlk!t?y׈
e<0AianKcB;_7^ph0<܍귛*BE4Q#vCL<чK`?бA*2⊫\$hA">yUbW%a	{A&l$xq,Qy B"~|[TH/
~ ;2\+D&`i6@-B6td{,ʵ,H$AI%]b"QxKfZԇ(evr6tfWLѓ<A	EH3M47Q3Nf0qE6\W_i9ꌧbEfK`Cu,=fmz^gCC*k99(d]@K4ii͕2E"``N]4}՞HyJ;3Ĝ(q$0н̔ͦHu⩞iT
P5&EU5QT4fs}3EzO=z+M"Xqbl.Q=G%,4f+!eۙn$aK(JB	Qc%.|"	%ڈfy%IowPöbf	\}$2Nv[lwIVUfn.q]`]-R"za^Җܸt-j07ml?aSPؼZ@hx%$|7aʆ\
Bd]0jC?r>)I$nÞ]97
N$	iH'6c!8i[|ƻyقO1⿦_5́lL}ʮd^Ђ@:'fѱ3󸚋,낞I31Wϧ\ޑ-|ypv{e::X^Ouw΋J
#6ՍuBXhafmXʎBTb9
@zk%FNlm	Hi^V1@k$.!
]ntllV?;6w -
t푼5&QHԛN꾉nb/αKT70[
BB|@HmP<%W0q6^tB2KER=f=oI\qٚB*^^Nus|ց˭{}p}e٩~2TC_{ZZ;Έ{|jk.}<گ|<@HPz3nrZA_uWz9z^@bO[xӾOJۍq%WO;+ܝO[Ͼ߁zH_O_Ї{}<~Ͽk?~S E0aƧg\Z'LAvr'|w'7!p+1*,A4qfpZft!gDBw"8!~({ւPƠzi0X@Xv\E%@z`':AЄW1RB\(~~uqU0ʄhN*;#hdܳd2"3d$BFL6 2h8 "` (ŽX,Ȏ)q4U45r3+k(fQ 69h1%  	iK1h`9␛RXjqU1 4$dݨC-qfv 9_9M%)#!$ (s2FC71?GM)(M0YXI
ho~6)+ASP
r`,&c0.tJ@-%4"qy)/-u0r-BX04`e'',riFQ{0pҘ:Q-syv,fYD2Yؤ-/#Shc☜ehTz1(){ٗA"*R97`iœ)y]t`%S)c*K9"ٚIp.	46)J/#846it;4>_$"V54@

JB4P8븙22
5S:~ciEW	P8&oZsIzP=iH%7A{S8xP(Ε*>b5#D#Js`_Y:]^"AC;7}Y*PR:Mi21kQ8+dکʩ c1PB#CӢU`7Ce3T	tM#Gi)]ú)$T(īc3{xq6!:X	7+)UCTMJVPDDUFEsZȪ7i(JJ>/$Q
J3PECD*B
WM?b*BD
!.	k &{(L_Z%T{$]AJ9]ZDMբDH^5+ZGZ/⊄!>{u,e¤5*`'R[cfG,\
nfT.=*LqRI5&`k^δA<2Hv+.:L4RD@kԵ@P*ںD."oVUPou(KW!^dCfTOش.I+HdыJ;z1#S_lSKIsE^(iaSSVVVdP6#%SZ.f]$x8V;ޫP !JE\50 JE<%˺;-T\^dZz8EK
X5{VLeC4ش"[Ӻ\YYy*KZegIJi^laWh]U9]&xy[GW]嚇*x[dɒKNJ)B2eZdj'3
pȍ"@|zh<Cܺ+{t8B!eiQ$:	hCdR
)kyZGaQfaX:;je6qYAgtYulhf'e";%	4V:6ΙV.pcVǜR!yђ
33G{*DVT	,KH0(lQo!?7q#mpɈq)cF1k	#P6*GrIqG2ӓ^w*
-
F~HJByKR>TM^Z\w嬛d^f~EPXoX @Sg_d{T7ڇ@@z.ga?XN1H>
4uN
	u!8֊7R`;OYNl@OO}n
`
IN6^+n
Gxy}|^+h!Fj+.QQ:^~R	H_HG_
T(Y9\=䐎sb!=^qqJ֔E	;4(%2Tjh`H?-hH>;A/_*>i(6DKI9-GD!b屒:n2Pvߐ!DI(2Q&(:(=(c
6Qfj5$A9wQ){F(LyFੜCE2͂DᲝLߛ7w"3ʟɗysr	":ߖ?⟵U40.(CٛrIߟ
%. 2!`*t+!00*žϨˌƚٯ+*
Sxˠ5"JA2j1liSX.Vhءq芍j_`,AXA!fp\JĎ^	L|	-0=f
`bh䒂Pcw[lZKvͻMK`mF9{6+;`t_2G#mͼJ{2_ѴY[^_nDee*Uiֶ̊9)Kj􈀁;

7Կ-Iv-bܸ1Ž!G<Qkss'LHl)G)
+G9Zv%aD4(XgMcbQW

t"|-bEc{J2vy#`[!%6XTL0c`_%;f&#R2S(?d{-	R 6/<	f6ʙh&|]UfNsNwdC&h@B:NVhDBK%z)c"|N$}yH$urD͡t	S
dڈyv[}u$&Pb$VۖZrȞ-IQ.{f{im8F-ncHo&zԡK&:g
J7J)R+or	;%kn?
-z|WjsEʑPpGbwm2:t(AAC%2	yȴc'H@tٰ(ИD0o{M,p-+}Kۯ\9ДY3^kօHGg5<-SZ9aYZ98,7N:i76Ny~y, \@Gߪ
莢HEvG{FDK~>>Ҫфv6Ky)pi'g;·P5qu"7=XOi_n[\0Pt禲@M'҃K*	bEXE
{+[r:Z.|1;8|?=P{;>ὧx:OQ
tp DbFs0OHٍa(Ӑ"@x({QPH}B:hAmF(KǗ>.c;12$D?Q|\Zv~$rhR9:NH!RٕÉ"j#
X:.<+]C!!819F
%6"9ᑚ:(ؒI95)ɚʼnDysҕ4=YJ+RBީ3N
z)r  iX6SHP<ԄH$ >70H%J3j5(+(HҜN4\&j͢PQ4;mHҙ鲣HM䏊JTܞj	]cթY/SU25EA5TJ5EXVϑD}}ҨMӦ.֭?Ee`Գ4 *:TQ-YWB!SSbhL6ӚiDRH֤CJm;[uA3)g˛DzwxÒKa;/;L卯|KrVvgqL`U7+La
>U1f 6q7kE(}PɷW1s_6qc+
HN]p^ȂTty|))[Y"2.m_~sLH2eN5,$kg)gyg[n>πMhP9#UpCF;ѐ']C>537N{Ӡ-hԨNWV[	6gMZָ3S̏p(|sd!"c1{xѾ򴿻mH._KjLc!AE]fdA5O$n^[Ug	zN)2zwu=_ex
݌.+Pf)ff3_[1KKJi-_{Cu:y687۳(ufj.}%7]|9飗JWtvCG+/}w6Kwb71	5Rq*ӡў,+%7_@X@؁
w'wDQF>OoNQo6iMFK+E)(;Ew^^zv|W:g~q}|GT']W-VtT}q"(!"($}ϰ~yoY)F1
X>XlW_y'ka-d#G؂!eZV
T@E;
py1!T^s0+mz%j/}-JTKm&
ph4w sчr1fHWV	
A:!SBi"Z?ccơ|߀!4pNQъ@

8f:XR,hKh/X0&#h`E(U8!dXȅ#-<$.Mp5\}/3QRA/7xpq&8x/qARax}Q؏#)7$q ဏ&r%~$K4Ra֦А0E@A@;KIB}y:&)&PXt%)J-Q
ُd/9A5_i)GXruCBR>'BS%m3,SPE-@"&S${XcҘ/'B{#Gq"62|	%n4)$Q*C)2y=C`l42H)6Úa4h1y*)I5H"[ 	])	Xr	$]B+aRZ8)yUnt-s:Re"0Y/fg#!6$RJ	:4.*ZIZ(}"}x:3I-*S-߆1Y,w0Uf9"3
3)WK?(O42F4}7'$z)5Z}ԠHs$hE%2=|#4"dW$E_yqr8`Ȝ*9KrPz嘂
Df§0q"c-#UCCW|3s=|9oF''s㧨
@֛=1VC'?کƩg㏐s@@5vZ:&%XKT:Z;53a+Cl
&7c8ʨN@Bi'2E6(ꪧӣDvQ蚠UG)
8@/T?9ԯ2w8\
ACvq6Ac^$9{BѳpرC$drD)mD+ʤBðcP
:1X<ei_+pѱD5@ez>Ȯy`	EF[UOM.uF3K4!$Z,1	:5FFH$KcIuK9.N Ng!KLTOs>لdO4IUSdRTg܂GHo۷^$GkN?EOĤ>tagṝ[z{K)$+ķĭ_q#Y奧We%[OGQ[H#skD]kU0uZHZj#\s,_DAgTTLZv5fXVZgق[Z\U-[zgS;'f%qE5f%4\
W`5ĵp%S<ܺ7快\J,Yى%+x `Y}Wu\65MEXUW>´)eKamZqtj7u<w,eb6{l1J_oZճ\ǀCȋl8b,6.F`Yauud\ǞhrʡdFel!zD_^|ˍfQ˸hs{+ʼ<`Ȝʼ̬b<h㪗ռ\t<\j|κvǓpd9h,<@h@X^<]	%ψc	i	qiRݵ]3=cLrqgf}昨،輂0)M󍈽:^jDy(5JCԳ푕9({.uz"nij'n/I)BRdҖ"0^IbB[+pxoɕgV\jm9YO"h4MYE)UDSh#+0r&^5F$x	Z	WHZ*m0Bh9~嘞qYn~azT.0',SAu[#:oK.uRzKnآ"SbFI,gXl*0wAj'R횞8;@:`׈*%v~Һ;'W2s(mh/R;.#9#C9k:zFo^9 w޵
Lk{Ó.1J
'1CnJi+2Af.Sġy,/? M^6ұ D.dt#ǻj]`:ѺOHCOߛrNKCv|%O?OzHHd~UT?dpIm?&:pм,NhI]oގgh?`PYŅӇ7l

m|aż$dUg4A\ZO5(=/Wk,]0%VX
lVZŸ3!.2*;)16!=1/ğŇ4ѯ+H

H &qʝ˵/%@hYQ.CI>	eCpɗV("d(LE`?@

eJ[,=$ʴӧPJjh•ʵׯ`Êjt]˶۷p*0iZx˷Hne뷰È+XB.KL寍mϠCyѨS^ͺTi;MʥsV{9ȓ>УKسkVJysOvś_Ͼ}o˟O?57;~Bhv6`[-VTYt~^$h>X`#02s1h㍠x< ܎>i)ؤ't|0<(@y	&M5R啳=B	)Z"0&bff'qɚ͝IM3TXI31I"4U喘<DQ)YIj8Ӫp">
d$Y)bH0+*frR,7
J"  ZBb,&;LU\yIʥPthRJQ1(*2[	.(	=Y#AOp n;ج0p%LL݂c:c#²I.+#Ê2Ii2s=o1gAfz"#Ѓꞻ
%2=p%
rHi!m&BORt&)|46,݈ʍ]"}+5P),x& 	~.?O}zij"1ܪ{Wu[{0{B囌r[?/wHMd;4:E[`rP{'
(ꢐޑWO9FaCnq@(
]&fw9F%W;Uq1aY	0%	Kk[uDMW&#'W6,ᶻJ܍y!R'A)hp@#"$:*-ٲV̅@XF)J_aV%gM  .
lMe5*cknR"ABBt
p	7/R̝7paUcd8b9␒W45
iMdi;]
^!EE$m,e/#+5]y$+W鏄d;uVG vLm*ԧ@Q[ڡtZ<'Flk@r R{ݛ^Up%g9G(K=ԉ 9`p
/LD[cKzTCH%'!XFږmjhdK(R8M
)X	鈶ktMVL,"UPFIJ*rtIY+MCxSۂ7
(_Zt`*4*5l #QVթ|_4:U365]u]ʡ!BX&03CAwħ[6ZO*,BUe50Vp5SDg+FTzVt"q|Ms"Syuj:*I)nBXp.5>	L^"!Fk>%'ӡ8i,B0Q
xEb/}v0##j<Å⅙io~V-DI\apT9X	
f ٹ
`)Q/kZRnڝ}U-h.95Ĥ\xKWQYZeBz(l'Ed^.2̬ iPVj~6:GHoh>w,3ʄ^Fe^zՏ%N#WRŗ0t:z
dyYK`".ToL4k_SႿ|C۲uXdm|nC.Iv8PN0DC,j׆Y.F)׸VF=^",%4`y4&ki6Ɠan*cfpkzV0O疘9'v젣>
sm)״`zٱza.*JUJ`SNnWT&|f]_"b`7$T|&T3pM.X"no?Z8`qf[-DYҤ^GSXلr}̗dtu}|Ҥs4%bS&9Yyw֟}m24h~'3dw;:KM=Q[bQnS*Z[h$xfkWoz04,'rVW3{Vv4XiF9jWN?l.
}*2hd>FKx`c5R-B}:(Nqw"_'C~,w`fT;>chxw4XqHaXRwW3"M5-^TR$r[R&*ݕ[C)1'xvx%IFVJF$(DI
-T)UNBI?Q$C)|D(!C+^ds[qG*tC˥E:)Nb-'#tuC=RA/P+9i2P6&IE-K)Q|>svK{	"r
7's
dFB ˤ
-	)yDGDWT0uB-/dGH4I(ԛyL)))7ytIr)By;)CМBBwXr
LrWyמmqwy~%yPgFQDG} I+ע:1$A
:
Zqڡz":1wA(*ڢ.*JAP`@)6!66V98J&F*=/A,?
U|0.p[I/+`Zx
r[yjN\ՕReĠ%CcLz*G*
Poj;sa)&:MP3mxeZާQ-F2@Xdw7f	gŰ33z

Z
 v&*!`9	xR8qT@VY͈}fs71	S=p,3y
`*

Z?
*z
$/:f*9/Éx.o"q.6"	@3Ϫ=B}`ںPҭ$UѮdLdDbVI	&-58HYSHDzzraɀ5]e4UULR4XkX2ӚERbrRJ7
¨qsTpDǵ\0AA_S6[߸["TNjYӸ@؟DSq#%pY+7'mf#yӾDՐhILuY05|J5rnT/EC
UIKVT;3#URa+lhC5Ys%'T=M*<&;SڶiH.)U:g;em@{'ǚ0ZV[F`H7nski@8i@5||
7C]νnblcx6PЮ,w'=wmz}#l8h2m@}k
v2.WueFJf8挈W]n5dJvfvjl]wvVNO-nu1r}㌬jW1$>3jRd~_ v/.h.:kt[7S9{lxc^Slx[~ӸVi]I2hV8P(V'<%sEuC.iӻV:^-^b\ڃD!(.^.G^ΐp~2ŒsXkX?^ʃ
U'pӁ>(nM7Ib6^gI˘.hfE88P"Ĵn7xu6:ݑ{<^w{i"C	Nyɝ_)]֙۩c/eVE[+HRio.jBT7pjm5^Y[a,(syYq/`03#*w[DS(e03o_y[O ;Y/~oPh/~itio*RKwch	`
$Jxİ/Z

)16!=1/+H*
ɞʥʊξ
̩+!.]K&Z5I,aԯÇ[7/xzW EIICiq E!Pɛ8sɳϟ@z*
]ʴӧPJjḥnʵׯ`ÊʪA5]˶۷p3K-LZ˷߿`tM	}(q3)S@@2eɀ
]FJ[?sllM	aVR$cWe q.]J9deNAǜyz}C7qOTΜ;AY7B[fBqW.M(%0fޔtE
s !`F}&vn)xBAGCqQO[j3M[ڛ.1&ۚH'&֭Kf9nmly*+ub)x
+n;	2p0q05ۯ@k-RܱxqMͣҬ IqHBH"!j*+ K\{27au&KJ
aS̓ 4#AKv*vEwJ4`-h@m@	M$)vdK]ırR
joktWֶ(R^;{sz;ÓBٲ,/v׽y@
;J +$7֫-F
)AGތ?vG&>4I/k=D2A(!$݂i mZU\%VYN.WTϏ2e9i|NJ`Hnt!	0ˋ */DpY#L7E6#E!re!	R=eu3:0Q]r!PM_ .*4x˓f_o	S"g,8U/~8LPV#|ZS'QESԦ9)p'Cvը`I,5c@Yɉ^	hbh"bpm$BXUԯNݪ3FUnU" rcgOh<T	椘Vն[g[B4>;#22+Z:WJ,
1?}QmEP7DK.ȯnZ#IQ5,Rv7UD
*q唬h13:`mE?
Ͱ)Ek_;޷p>(+"+d'?.#Y Cp0PcfXj2V"msA'wniZ*j,~
uJ&,K7ʌb'KEZQS	7Vj!y]|ˬ
sYЃzg_Mwܮ(]5Q]ޣ/&m_5jD6SC=o_!H#a̾}ha`"KkTw9t=eڤ	
FcY.ķ}y~HoLj28"ӗiZ'xeW7\8!wcETk/'H)1)2'3(hDЂ2cfC*EPg<7x,~XE9+S,R2/2;Pp,s+*Hrkb"\XDHMfAkA;D=Bz*IkjVC0Ww*V%=Dd\%©۳D(Ҫ$
K#d`TtAMX\NAgW%E[V*V
LJ|GOu5&DP`/tU-JT*4r#MH4խGxu\fW"hy
c"r䵩Dga.Kl[F
["L_lDjkU\+w{LAWdZz#̥#{E[a
˩^Xu7&2b^EEhƳ	{[m4HR."R%7Wpci"`>V e;}z{@e+qtWDفe!Y'Q0+,%dH	dWP0X[{R{ËV{uŻV}B1H\f4[SPuk_%`{\^dxJ;:uV%#aT5P	dRkU·c]S.k!SþoS"
d\#n2J1(0Oalǖyy6ZijazX\j`|K셾G`c\Klr;Eh34qbR}̹
cF&xhNM`JRJ1X+.A<,\V
`C#f6.<{5%|idVh̠#LIfdq)'dic@`vʋa$\tAY"DeE[lv?u<ͅ:;)qsӌ~oO|ZCŸLV&qks%nf=L$MhA˨|3"|3,qDqwHl㦘e.ҀnWu3iv9(;9ϱ쮑6Q2o׌7lv#-vp%lpJ\^m>}q9\]}}gDbV}GJHƼv3xG{T~Z5{Gz7qz`7+jw$ׄwTGT7A"'AވA'~қa|BwvMS+~=w؉$'xgr/\\d}W|]|Uxwyz'~JO%䁭T'/t{[]@V
M
׎ϭ}lhsXg'fFX+eńu*-m؀[ڟ&9$S.BH1S-qO
2.0'(>r6ؓ,>iȀgع3)n^ c(36ENOn;`^!	 C0qh*M\_3E9ާȶ9!?7a
^'^餾)8ڱрAנ
&,&qэ;'LA/`.FQ
)>^^>~n?;	5kI5ʑ710NŠ P0&
Jɐ9Q%*mj 	;?6LIL
8_n:/QdR`VXoM0?+9	m
i
qosY*
2!.ġ̭ӌĴ.ȋ.櫧ҿվ-*׍#-	
C,؄aޫh$qaGbQ*@H&Rw FFLgk8AH*5A6BXHa %hٕ+*$p)TG`	RDvW,tJ8DUXb^s	\jJA	qƃ;BA)wב4ۘ潞
8[CuC/ֱ7+LSh,:S۝mewuK?w|U,c6i׉hpv!)`jrkg[Op)tN\2HjlҟcEw^)2sɁ즠(8nuF"F@RM=TU%c"WY%V "f$5CL))dq
?Dy09=E'&}LٖIP&9$PO,JcF5B;"fy:K	RF\rl*x:k~B뤤
(|HZd&p[Bmd޸kwJz)9PB#ZSKOl LʹdOBTRQeM_E0]810`Rn(`n|@)n0+)LdD!}'wMHx@xNFTSyq4IW
`s%lgjHjjM\;C6;63"J>~aI6嘣߉6۟ЛY*&ux+mY#vD}_h:E|W;e0Rֺ\bI
DByh54eOw
($7m$I`[0b"N~HwjۋQ|Mbj=1d2Ƞg2Jz,[/řP8?鵮tc`pGu)ia>)
s!59JTzB|LrHLvRL$ ?gKƑd4TGm$
,hҷbJ/Ģ5G/]UDad+sO>mMUɖ4c#FJh9N@tՆʘg3ȜI>P(/x
Z,D@^W	
VkŅV5pV:Z;&8="ˤ"	46ȟEmRzv1T]nsHosS~sf)2&"T\̫&N)bʟf2E9J;Xxx'YB1 Li=jPP,dI4>J 
BAJ.
 yPtDPPO$P1flnhjδeIsVcut0Mr2umJSJ*WgtT,[)ssdO٤R#m˴}jtG_<p!8~4f~c@(@a7)*kw	PT/Yj,s,lc3xfT,%I47G@
p
;o1rRn!`
U3\d$ĭx#_ŀ*;a2܉uI;HNQ%KZ=Nׁ/@%tǺ:@"&gG@ݹEeQ|h(]̀3Li/W9J5:P$~9b-/qNFi1ӄ>sKD׎,g2ؕFkG+	ev@\@Pgh(Sپ^`HXɳǀMyf	~>7o=xZO ;\.NכI]#5Z%Α)9dC+cNs.bvݖ·#F?8ї3=tw'[Uoշ.'XJ2q=Hr.+v;!]vPq\Oz5'񐏼'O[|9؁~{G?Gl%Wֻ'DyϽw{{]~O}
Q@;t[''V±/x_OBJJ~ZcY: 4RYޗED7z8ru(ss?oHTkL{|T?
7=`3#h#!YQF~]

7g&&o.'q>t zXSq!qwYOsxƪ~РӏwqO&2>qp36g廣w>'׀W'椓*3@Usf7G1;͋SpyƂH0KnNst^GFXhنwKsL7Ê	'\nۛp$nGDܜ"1q>e
I.\=K*
 *2
!.+?+ǎŅȄֱ֙͑ਠ迖쒺©̾~ڵFQŁ Fup\'^AO5#&u70.΅A[mhSceAU[,řnN.D‰Bu>%ؚuGe&d<(R)%C]67Tɕy7cE5蠃ETRQe:զ	}7[@Q3 Va8i4}P"ox_6tqNLx^%/gOm|eφYJrԡXy$_aK]9$Zʅ5RH%Dd3.3>HaE
Iוp
P-wreYˠQWH8r
0I^^֦FX1*Yd/zY@׉8d,k>믑 ;,OE5UUWG)\||ډ(eq-*a`*t)`=/BTvd

e#^
qI[n-$w+ZӟKOӔe
&?"̤;z-#j2WԷ*Ȫb&D
0s6+ h.{*b7xؘ75xCqx0rO}$9ᝋOb/Ҷi[xs,f:Ƕ:Δ~#Bί:3Cj>zʛs5?,'I
#F 1a'/y	JSSAw@'	O
@pmɪHVȂ4v354WI>E3F}z`k8Bw$my2U=!w0Pd9c:;]فoɔaE:3$$FS!f$ilF%Wy	|vN_fOƓ/Ť\'i$/RW0d/xj:A<@>:gzlұg:AaZN|+ڼ:9=QN)\hWqmlg ]FUaW7HBs,m\ȮLDpQR-JqKZAMuZ]2̭(kݕgQ|-*b/~R-Oͻkx}i/,"Y6׿q!,<6C,$
(~Kx(8αwX1%tHN&83x*[XβcF`3L^.hNg8Kmγ>=ObBЈNF;ѐ'MJ[Ҙδ7N{ӠGMRԨNW}A?XgMZָεe]MbNf;ٱ5M\K޵nlMrN
pMzη~O[N{F!ow#N[ϸ7qO =ruo߭0gNsy/ݭn̯v@w0T
G
p`F7*@^z#T.9Nx9qjA7;i?qo^h+ՂTw`T	* 
U@֫!ON{ڋ@hv:p!@`Bhၾw(EOYX0 (
H65ؿ
T쭷- N7{Vr7g{!w7X|wxYyNNm(#PjuP& Wn64h5
mUoz'7~bGt`y7v`0zXj0PV{RGFpW}<׀icrl؆nqnη|IJx8,|J}UZx6U}1x6WnUbWz-@vG:U(T>n7PP707@cHe6z0\`({(؆%z``%8xZЈGt9hSJ؉w{c vKX-&j(gG@KDv`'{ʘ6hm ЍH>@IwqWk|y8kvLiOfz
`VI7}GtF`Qe 6GP>W#P-U|vyde67yR`nؒhf(zԸԸ@@DYy7InfN"qXK6bW	)TIHv+E7vR'}yy6`
~uzw){i)uRǐ(/٘(9y{ٞ6)p!̷]iKI{~MmRI	tIvc'vJ6}G{ yL(FcKY(n(YȄ(qޙ6z y69@Bzn)GXN\#VUgyIhSxʥ[Jtm	w~VXC&)Vh	f*ꋅ@wƒ߉5:ɣ&9A*}gh@~)Rygt6M	fFa*n|G v%j@ęy0gÅ:蒆	r 49z6>:-( p:EJOcUnX:`:nW{zhnCH&puͩzDFPiP	{gh۸{[r(@*涔LvF
Xz# fyEWWnNwmqG6;4k0jn96/8ZW[D[>9+y䦈>K	ٱԺF[VˆTY+fxO[f)0d[f{hjl۶npr;t[v{xz|۷~;[{d5@88;[8۹;[{ۺ;[{ۻ۸!`;[{țʻۼ;[{؛ڻ۽;[{諼!۾;[{ۿ<\|
;PKNkaPK&AOEBPS/img/ccapp018.gifGcGIF89aCM			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~,CM	H*\ȰÇ#JHŋ3jȱǏ CIɓ(S\ɲ%GbʜI͛8s	ťϟ@
JQ1ZʴӧPJHL Gjʵׯ!cB ]˶۷pOhwYYڸL-@ޢ/me[˘3<&5`du@r[-Oװc_lK\kȓ+_^@wm@l	$Κ{t.*pZ6A˟O~Ai#Ʒ=w}&k
4grRu׍ӏA.@ܲ]da,bs,X2Њ/%}X=8hQ(
PFInPщ1䤔`)@Txэ96pc	hHVd6LZwr*htdnQe9裐WA!]D@*jldh1:|!Y9~g|jk
i#8PdP&VUze
@
diE*Z1g1I302};ܶQ	 P@@:*+@+мOBgo㧯c/7eC?#/&Z/HwBS4(L
OB	y՟F ҵ\i' D">3>b Hp)
+d`L\H?A`H2\_$B@ol(/PtA?
tA $ES鱜A~ьF	"Er]6HWad,7@A"EБXAiIM}`66AVJiސ	-	A[Ző4@nHL<:؇,t&4i"Exh*J0|r;lI_ӛԥ@19(:IQ}sLjaGBA&?pJ|-ƥO2k63Rr_jƱris!-
ٔ/]3caLCO2>t4W
+n	[t8}1i =fdL@\t52jQں6[Pw1>et	\t	鵯h v錼T
`auiO[m-;pkhGt @A4hpsNx:@d\/R0o:2dckIRK6Pe`8g+9|cLr|`*rHyUUsa8@AaBC>h^
ȯO30C7WuOXl oG у1R?tIJAJdꚭ3unm:6Qas}C|~0Ɍ٧w`*},`,	h9iW}pX!Wx4k|1xWAw,wrfvO,hfiB{&c3X8qim!(˧=44MX%wXQ}=	jF|FXg+WHQ}\X0Zt {6o|"X4kNmx
q8t27)XH}$E2ix+Wl'D&H!#y>%yﳒ,.	?01S68?:ѓ@B?DYqJL?No4TV	AX]/ԕ^`	Cb9DQjth	jIl^cGY:Ao1izIUxsdq&B9,
iqAIHzf.oAAc!B$4~BfY^{OqP86g~9YyșʹٜƉ&g 
z16ϠعPyev7T5vt^{AJyi!AR=5B,`eI5Q;N)y_VϤvmvAKXGhS~ ":$Z&z(*,ZRqO@?z
gvivy)9uIhFD?q2{6GjM:ZHWWԩOGS56q @i{H.$Mhڇ[-|ڧ~$)؄<O
OAA}SqtixnQFMğ)oVKz=a9|=qG`-:TL^jQL9aqց;[Jo
R:Gl<4iP2թoVuWKIKP2S5{N)E	@[BeQB%Xf'ES~VG@K0wk7R[{)zš	GT: CQ{H@[n%4(8Д2hunR5JJgVT\\rEW
1	0:35
CYa;Yk	׿PQ5PCe[eXy xP8佉KW6ŽX *_
 [;h,:I!a„z*&5|PÛ%@π<Bܬ	C ?3	?n?j/h sl 	1D"ȤZǣW0K_
/~ƽ}}~3ʽn/ʭZsl&?pLXkAGp+;U?NLWyCJPxТOC[}ļ
QGeAWhH3}!KV1aBGh4tC\Zٵ]%Q	vj:NxOc
hA_	\07E
e1}39`JDaB#9:{mMi3auh	:mB*k3tMo{
D0¡<ʬ `|>_P_0ԔmF]N%uf`i^7pCb?f`"+H@wvG2bvTc]F}`֘}ǙsDg;%+Lݬǀ,dž{ײ_Ѐ}?`Ȗ}fPb;oh
&wP6cVf.xeV@&m?>Us$j&/,ƥ\l>$Gߢ#}wx8Drv6i|]DgOTu1_7J0%Nƞw/e|l\/?ÄhLz2 ʐ?jlSϢ/P0i?i_?0~]J@	gW?i~|O3MJwʎ@ح׍&Z**\h
`M_h
ϧOO[σ$XA	?~MX"E?.8'=/4?
nkMF~3{s/NvĄSNZ*gnWaŎ%[YivG[}Υ[.]}_S'^|x^ɕ/gPkSzUf6Ib̹L6B夥i9У{|xPg2m@T0w~j}mB
+2°9@hh+,^zLR `'7܀@K\mq4ҝ5孽bmE煝 Ù<OL}ډs΀11:&7)
)T%^0?g,-NjRC
0AO~^t0I qP@~$,^#N2h}k?靶>/	p@`&q
-Pb
7$*ƋF~.:z1c$_Ie#8";MbJJ1FxTh,-p{#z	,D"?@!ِ{YQjCDXdZBFz@1:%?>~x#ieAa)]	<
sQ`
QB<)3 3BMLBy.u)	ٖàyXfRk8yŚp%yI=NG#d&X'2jCa
hI|l84MePII,CIA6!@%d=v	t&iGgҐu1A.ML
9"d
o"QO`ɫ^KHUi`E&XMD6&8Nt'@PB(~
rtXKа󵳅`KjXy9[gWx4hHCӠ5a
^І6
nA^-\M%oEl{[@eY!\gEr1
:֐.unxCn{2&tE@k`ܠpw{G;qC 9qs0W`?u1mbG~q}\.q[cK^;:YBr|򔽌-X&EewkellYss|g=
_-\ 'RS)ۊ>>f۟d=+K?})܃'B)@I4!ȳ!o`@zھR@1;bA[L@+c4q; l:m̀-&<)" t,c0Bm15$>
Kg)"r
|:}3pB-ܡga:(GkA#':PbicÞ+^I9,c	ó;Hb:83Ds=A=F=j"H"01aWb	\4AqCC`u<[Z@	>Y\>䊟{!: PT{8B"jC؃>-QN$wؓ&TKjC$mx$N-wxG@,AS#z<-+oB-#|I0qI(A+Ƥ
L>[H[ɧJ|Q<9ԧ-e <KJ!scŨ̧>\XX|K;[:!H:H";[:4yG?HMBLp[DBsDSljK#J|y$tFgǿWx)$yP`7ͬpBL ItIe`I,ɉ,ll>w{1	b4x̙yp+ίA"HAAf@
)O۱+OLXHN;:[55͜:Jf±MB'Ap1Dz@POlyjĽd,bA5DbϿ{ Q	HH/e"Dϼ@عFp@1QR)Ҍ!"
O$=bkOtQB!@z\:E
ȇ/so PɄg֡QV#;ÒExS*-֯0lLRGƙg(iCIXe hUyU{9G+jL;bњQQbP$wx%r*DhXaؙTW(HDWdSڀW%ٳټ`W~S-]Ԋ
[M$< H:X"TuMԣ^FrU{5̼ٟJC4@.MϽ@PYdRK
AY1ͭe+TɅA2}ԯ)
a8=΢#\Q[@^ 8ݮ[݄L}QNNΣإ=PU0 jܬP88T4j]:{?HwX"ܱҧ܈10EޑSAl;
X0=3Zë+Ac:
910j`
ի͊VZm/08H-]v
;8`mu9i[ˋ18kpC4?
&/[J|$	:}k9{t ߈-9ّ2Hk<(aw$d
9+)81Ip(dݿU4 N^߁k^:!zU79c^%DM A<f/9*7JnjL^,E^%c]_Qni1⒰nWjieȅ
|f\:\BRGR;+n/"|R,-؂EbILpeɪiNF<cAqyZ<[=CCF\d>E]{a-bșɡ{Nq"%|]0AʻƬ@0q|Yw9&FaYh|&d͛0gdC";ML(N@Skiq "
$INb)@)=jRƍjLS>8*:j[WNS[i޶樮`jIC:'P6Y90 8Z0taJ
N[|Şꆀ^nhN2?CJiԯg|&lɒs^o^;{ڤٰ)EXIW o˞}'n^nbl*>{e*n~|ֺ[c;XrLD4E^[zLɪ,:"B

gYgFOam㶛#m-3G3XǧSn$4̽zYKE<`害79σko>Ѭ_907F@L0 bǒB?v!f\\=ř0H vxCެƠ#⋫P!"x#9ވ(: }%#D:${SB;"Yje؀M
PT&M
qʩ `i\깥-&dBAQCsNv4ƛ!:)f?_AyfyI%|C?AA
S)icgn"()kI<@IAb/N!}Q

*JN˜,@B5
m˔;<:}JhlJ5ض};o፻3ca
"0glu?}%~
W'wy*%Pld~̎89pS\T@ /*Ty>
Ykѳц9KP0bA!72/6/nu۽8Ip@٬=sMS}͏>&/'sp6\cxUxcy:| cj|ыS+π'@A#p'P9/s=CI	/ֽNnږ1Ge.=ݱ
d8@
Ȇ;
Cq
8/$k`އ%vg;j_h$ %q{{pXBC,$00X!G).vE*i
)0/p}\/%.F)6a;P7c>Q]z04Et' *WGWoĘ%-O
z]*Ep\CJc{%9~nvq'@5!=AmЅ.mb(F1z2e=AyC0
	EJLc*;daAZx7iip{e6}վ9D8|7)`%~ V>@z "#A0~+`3:udHIx,f3s@r*!PE1p|=iPU9(!6W@w@)WjnHTBR+<`R":u#pB%@Lcawؒʃ};1fw.:q 91q8%i}
TZc5c+[E-7W|B?^gt8k{vϹe#"cc׾nx
E^L}hzC:Ro;jl#,`-iQ;:X1&,f473#PGKeG}dIe0O`68F,%5n'廎Osj20)ܳ`1l;H~.OCxD@{5NwY# A3`l8M7FѝYڻ51EߖՃ!a_1"
%Q4#e$P!Oiާ-u]ÅU0^U\ 	$7L	Ly=II@^D}\ze`)1IU`2(CSϔ9h]8Yey蕚Q1Fa֥0]$ !W!hQX!y`!=_		k]!9pU
bUElD""ʴ!$##8^#X *S9	K7v0Ja
4,]!Z[bc"#uc%U=OoVu-[#n\yAAcU7졉]ALޅtL+Z`` ?֢-@A	^BB2|CQ%i+4Xi/;a4tIWuvE=]ڕcԉ'@eeEda]Ǹ%]F+>cQcd)%	$A2,3Hgbni&iZ 2ad6eݡ=%lfg~&prFJ#b#Z+b,%@ .de2ak1
g6Cpe #ad62'PvPFN'd~ 	/z'3x!gY<я=fP&bcJ"RN}egf@
%5>r=a".ܵ!--&b:ew"N~(
q^#"=
`u0{:(cUg}Ρ.ZfSNߍBJ38hph\r
HȊ})gҦu(rg
B
zh=^zHi{鯠ilhFfZJvfBÝn)&
]zz(gjn"93Pj~&Zu*>fgR&fFC~́韊iH|ujcg(FkBC4HòzpAGBGnjvjjhb(tlR>)fj(oB42pYFWZ~"HXҫs+jRhmBi槍)46sVc(e˾,,)RJl:b'~dzR
pq"*("Ӫ4-FN-ܬmbhBJ4ж`v^+u`hmh*^ZV٢-J#¡I+jΉ"+ςkQC5XCf_(ᾫVNG^,:i'P\e.z&gfdG@6g>gŒ*6ΨBJ^_¡Zr.>G.ƞ+R6n>GJlR>vkfo(z5*H2l:FqLT/un^6hC[ʏi){/2.+F*6dGͪmB/v"Z*數
U.GlpʩU6Mp*qfp
0i0lpci6plh1
kq7qbo*0O/6t7Hlp( n-h *2ұk*r6M0=Ak#grrh22floJ.Ө2

&33h83@3J㢮n7|8h3-qj899#.o)2Ӹs}s%4.m.&/l(q?k?;}C8Ar3tvr~rDKw-)s/ckGw	ɳ72g&Ig+JJ'ڭKWF4MoG+2/4I@jOO+鶮.kQ9,%^ufPnm.B:8Y3uhj[o2'>(K4W45{]+A)@52KuZ;t
pJoPasb_9Oc|ߊbu䳋3E5S8@Ei/"Y+A4Ps[{v:/	 9Tݬ'y
_cpkx7yy7zk`t (VlspRLb@uv/9C>QZU2JDɬ/878{*`o|G3~6t724
:CO2!́8Ae\+׸8??'8yƒo`|_s۷#
/C:;xC^3B&9:ٙ949׹y{ ArW9Cy}ϱ#BG:x4By69sC泑0#a*IS+]C2xf]vC<;Ƿ[[Qc$4 z;CO%ӽ.zWWA%l A6dÃ#
vgӷ74

\tܺTZٸ4nq씵>Q5EΒֳ`Al^+keˏw+f,Ae;LvL#m$(ƶP\ɱlb/TZ,X0֯=^QdJTe-v*|V;0hΊdjWAYј8YNsT:٩;PKHYšGGPK&AOEBPS/img/ccapp012.gifidGIF89a
			a<$$$+++!!!z   忿rrr666@@@Ϗ???UUU}}}㲲999OOO:::ТŸwwwΣAAAvvvsss777DDDuuuHHHeeeppplllyyy>>>___iiihhh|||zzz///jjjCCCǓ\\\~~~Ťccc&&&]]](((333'''{{{bbb,,,^^^===ttt555NNNkkkfffEEE000QQQ;;;nnn```LLLTTTYYYoooGGG<<<---XXXVVV[[[xxxqqq888222RRRIIIPPPggg...SSSWWWBBBKKKZZZddd444FFF111)))MMMaaammmJJJN[}Eļ<6$̫ƚ!,
	H*\ȰÇ#JHŋ3jȱǏ CIɓ(S\ɲ˗0cʜIMD.􏉞F&I#č'h)QbPX1XruУq\s5Rp	IHƦݻx[#+
CEqvr*\FD,I&IՋ5
M%h}A
of6nH>2P\gq ҫ]μ'(ҿ$A$̐;\2!o9~@A~`h#KHB2@LsJ>;\`
;L\	`2A51Am2K@7B`F,t
DQM$4D?lAP#C$
  pP@'@6NBQ?H2P5ԌH\!vx2rJN$ݦv588ss3$&;qSCx9pȡwl?(9߰L' 3
-1gD+#2_2?$
 OMbP:BZbMA-t@@00"$Ez2(H?ȢMT
0`1A|r@34rABqC,3&1fLA0,NjKt	eL?(x7Ks,?~`,q%q3T88U`a5K?t`
?C0s{^vD<#R4^,T9 I	lA٨)P
AP8y"-o	(1dQ
4
B?o4G&hw
AyÅ0HBD#Q.T,?r;cE,> fDTn5춷8Hf	BExf:Am%Ag Māx|A*Ct%( ,@<8F ]#t0biO{AX|0 ;UD`ЉA)pE,pu#(p0AlA$N6E(AqJPmb7t	%l |q8`A#8Q&!3̡8IN0p>,\Ab P	4QbNÈAXІ	r*pIđ]sc'E<#M)"v U腁‰byDAN=<2%m7pXBna6y@qew("td,@q%\;с	.h4=xjÚ'?o
`s
KPGna&:R/Qb^w(8AC ܀"
gEGQ;6hPECi|s>{5Y 8EȠ& C#p	3&3!c0w|r_-$*7+'S0+UpoG7m+U!hh'trx'@+	p`
'07)
-0p10 Ӡ"0`P P1̐
b8"q@b0IR,p	O BP-
M	.7@	,psV#C^
f
x{
x]P|
g`e-@
pr0
Ҁ=lu	&65Vp
'(
u#@fh?UG`%Au
0	u xU@C+JZ`0,0	
Ё/*0vBXΰBV"e	W@
.N9f@P;pp0	`HÀo 6P.Ii+5&4a 'på;
  
l 'HO
P'-@~I`)e'z@(wY֙f5]7Y\6P>К*噂!VCYBP	7frQR.0RP`!iz|h
>	p-j

aE)A	pZ@	@p 

Je'+8ב5 "J6T= /7P8hP#@lv7 B0!`oPGp
Z: @
%
; 	a&UPUʦ`
.ĠjpoE'HI$E:8Т`6 8PϠl"	 1Z&zPZI@r
Rp#}P
̀`W 
PpPp
%E`
]PA|f 0
%P3$p@
 B8`u
sP~7c'אL`B0CPs@p	 ,19'u0	`
?0r\$
@L˰D	~F
;  р4}PEa07C	 `Ġ
P'Q t
zbp"xP-"
"p.`0PհG
cnzm	{D
PPb+z|
	tbpH 	7Bc`y[&}x
mX+y6i 6`@K8u 8@C
h *7%7PZ	
3@U	,yBۋ	P&0	8&iBku@!=*ۿ+W` p s H;q(A0|'=0P$S)
bȋSP:\ 
N 
3PT,]:ĦPI4
렾ɭ/=PBƏ o0]pD`
0
kP'}`~s
' P`#`8`P]0X@@9*xz0g@Cࡃ  Q80(2
*3`ց
S
rcQ1~`)jPx k 0~p!0{=0q~	/P	uph
D	o	5Ű nU}P
uZՆ9pMLJ!#ؔ-0	'P/P?=P/`putA`Qٌu qw`NbP
ޠ	@36 	 @
RPI4`'	({
{u)|L1p0
0	-P0K@PV


 
@
w`" n0~@zI.=	۰)`0kP(`J SC
ҕDp쥡Pt*
>`P;nd0?pzvP'
vQBP
Հ
I	 %Du4IUX)aqXBA	YVVqEWu"Ë"5@]@F
d
_Tg”ԽƨoåR<Ȁ-+*4Ʃ;JE`f7DI:;v.jǎ"9SDT@`JLZXք+N)Yy:8'E&DzȆZy",
$P!	T(ņ6p&l	₆X%xa̭8dgRȠmhc'	JuJh'QkV@Œ)Xk9t)
{&B~ie݊Vx9)6A
6*jBQCP`*Pp@-,!8G;
`6aj1bX؄c0AFR
%́W@
AG6H4`
^*eg"
p;A pL@O@I4E',	X-XNdXBƽyk	CR p$= TB< m &"&b1@	k	bp`	 "!pVıwXcq?R$,ZVRL'AP^Sxwؓ/~Я#h)Ђ+xAu(&ac$5 1؂)Xz}͏bL֧ DZi`i:Pl`xfq1A$vQD<$@3c ) a#.X
A1ox` 7@0alЁ4@	a@yV@-ܩ$CXZ։nHX,ZhE
 "	p&Q;L&[0,sC8A	0cs%"'ONP[@̀92jL
M=ymmZ.Z(#
At6(6r0@ӠІ=(#YMoDiFdڋW8%P/| 	7O1Mb5`0- za[Ԅu,am+AJi(
(P\Pb
0R@<$0eL0g6HtzMHB
{WA1-IQ	BXQp1-jO|mY;)+#Dt@(
$YlN/ H8qhLq?pbdH4[N64ݽjRAQ"Ѕ:S4"pEoWLj-ahKFL;@j)?)
0Ă	w#T PR$P
GAq(TT.͙Ds;aA(2D`m&p=FhB(h<c$JP yHE ,Qqc	$ VЄs"X ")6Qr(ED0LM0B lpYhhUx%En)PC,
1l.Cp^*8`)-P3f]O

hѾ

AiqB=t?sODo8});7A/\dL?N |Ohlurۉ*ROP?E@0a |d"hG-^F?GX-@E(t#2#pCZP66&i Zpj`JB0]Ѓ&nX(H"I77o@X
PPLһ
2-%س"AX=x	™,؃4>i760Ң8
8hs웸m3
@)@TxU܏w1 
H,p0v]H&`N@@PhЃ=pBȅH-m@$HkhPß0?І)n
I82_Z8H8ZhNB>	h%SHLWT [8+2-3#2q(
(+3yŊRET/܏3+[E86Oe
:(L8-8>	BȀ)=_< ؓ!X0!hkQx	w`n@.=AP nx`D^sPqH[%\P	2UxR^WXUP _2:Xb++ɖ,MDH0jx6[48	hhw;bt[ȂD.PV$	@Q`P%VnVoVpeVZ}'BHr]DXtBڋ%Vh1@<<++@w G`yVtiYH `($xYYY%`;5RARR=H0hpxЁ4ȁ'ht,dD]AhE@xhЀ(0/3m0OP>hMEP(W:X\m\}\ȥ>r	ܝPW1\6y6Hu־# GO,Y-Տ&؆!X7]
^u14ҙ];P	hv]ꥊ
Xs	X0@EQ͉0W]ݏ&X:x_`nH]ߜ5K
ĆPЄU*h^_(=M`Zy_`7 -an.81h]^F	&IFC?H`﭂#^8V`]
~a`Za&Mna&a,@'N1
3  0 ]#f	$`b.i_b?Faf;lLU;1^ڑ
p/05?`f.6Kcc\bBn=>?b+dbCWxFf)c@KL\ݟ$Rv.'fT^e*ne,&X^\'d,`fLcΉ'zt]@fg_ fn8eֈ怾_jdl)SDZgM@V)Hguf5bV<
CiB+hg^*j~-nfR̆L}/.u^9@i(Yh\A0a|g~j~k^]l0k>?lAhinWfb>@`H;<
c36((jjMV>f	
enIi]?x`0
mڮm۾mmmmPqR.Fj`HIk&H^ 300qH&iMV@_dՎ;Ή0#oom,`!n0nFnk.jl6lnEI(grB8
7iT  ).oaVox7Lmooq J1pFpƦ_vpx'`"(;("1N`p;U89 (qGqmo0r$>
PWb	 ?tD!p`!@VrXVfn(r*+NoHbPShq0*CxaD(ȁxs8?&irxV<,+؏?'@GEi-DvjE/`t¦tLtNx(@S LCv`h*0Zh;؂Q`@H;,h@h]s(_7oτa?fghoCmHy_yoyy'2۾v!5rJvVtqrrsGwHٶ']Xsw?y>11@epez;(%kd`s؁@xنu^x_s׹V2kƗ'mGwT.@(n@.6. ufvIgJprt?wHzXz*W2*,(>sПeP8ȃ2Hul$HA$({^svK{w<@/>;8@rnAˌ
2l!Ĉ 2"ƌ
1

	 O?
2gҜ̘6it'РB%Bߊ'NhʂE >ybʐ=z@6jUȑ:r!rq$zM`D$I,a	4D
nP1#G @2Eh$daL^
3IІBQK!
%E@1!‡c!F ҧSn:ڵ+|A7H~"\;Y%x 'Ez͚FBG`!ڛż=xG2P`]t"<NȐ-o*dQt@,q 0#
|!P-L:$M )EPTtC44P)@@D>yM'p"e4At!F~(ƌ!DߖDQs"@
e/8]hB>
nI!@3	0(@:mp7tR(m|c$
Eɉ!4b 16H%ΐBd:L)A0gȤha/_#?Kd?41T@?qDINs!L&%7fΙ&)b?p'pnҋ9UNRf
?B0<\#r?f} Y	
!ܦ<瀒4'HCPmd"	E)ZъXԢ&4Χf$'\[`@
1Os:bpAӇD !%klRbVVQF:%1VN"(f|
8M-Ҡn ,qX26p×A:H?	HG`#r(#Qu9BO`a;@JCfc%RҤ5Mnzg-;> ,jbE6l10?l+q>p;VX
XA吮p2@хW>Q,c;2wHQz"ݬI}|:QB@V,f`H7@
6~{`:R.dN3`]cyOv$)33/cS,d7Cf9vHCퟒ
rC,5^msCr4b!Ҙ@@@߹ʞ[?zSD8chS;)I+4u6]N!5Km!w :AU`SBbQB )#q?\aYyeLP<:/u?5Q O$
ML`!]p@ XT?3FrXp	LC`THXA09NouM7w~_N0bĿԩ?0PH,KSn&lݎ'Hgg!60|cȆQ
@	" `4X8H6icg7}v5jB-R
ܫ]P(.Ķ(1Bśil P?  z@)D Y9T5p*C!(?CLCHL
500T@@1_
-ߺ:)}?)+@LZ%@5,20?wHB.D O#J8Aԡ!!!<`uLZCѝ@1?\KtH?l`!M"( ,uCX,MEQ5.D
7tTQ1\\:#;;#<ƣ<#= N!V8,B#Z j V@C58ȂB4$C*D]x28B+BĢ,	9BtAE-$S-D
D!B"C\74?d+ȄD!F@&@<)C Z7Oa-PA  P(;d^@??D??T2?x
\p*^-CT-F~‰=J$MТCP>}% -M](IcQDB
!`+R,0$r%0QR388,DZ.P[VG pC&2@1R!؜?p0T\ܥ>UT(Y&VCTt&}t6&K6C@0?dBk%FzBhE8,"F8?AB;%?W4CL(0
t@&8@xa3hDpgww>t4g&u(lDZiRMQRҦD٠EA6pYfBO\?Ѐ)u????l.DDW1FD"(D
8U0-JEFD<@"/,?*
s%CTA
J*,[Ṉl<
έ+Q-M<-U	$DD0B`2 ?XttdT	%@L-D9|ɭ&
D,mD?\B?phhھCdBiÒ-`Pn|""*0t)m߆$l3|@(Tv	NCO"\*hzA',#$CC#HA,
$L@4HDP(@*fDC(*7q&;B@(|W#L#oeF/L/nZV>RG2A7|3l
dVǙNx0Do]	D.B0@\@:@,D$p;L0?8A5BBV0K#1(1݊h]JhnD[q2A6C PG/@`-ƬC?)ayÂ9
p4 Lt@.@X,\@0ô.&˟
m2''eCf2@*;ްr2AtB-&R~@T>DMQVSW<4www~Zh0A'B46<65(F&(7AtB/"S	2A1,B$%p/@X$5HCt@A*Cpxw*K"WOw4"
+,6;+t0Br?$eTK@>a
gC!;\>/@9X*ƂR6$Be
"zb++:)h[-HuB?Ѐ0RB.,PQ)) <,zz牁?t?D?LMۺn8B#/'UïcO#{*{2;86xآ]HB1Bp/r2C΂8:0<4bL7BܺF`+xB\1G$=t&O@	y/DBCUΝ{6<'?< 7D3Aoq}#0C)h"l"|<||K"+3+
D-xBZ70D:A)4BB|Aʒ=Doϰ??z{l@FDŷfDAl	4~ЀA,[J	2ԉ6J[/Wd`\_04lC+0bDTwgN;y7,feKK6ujTMpkV[r5Jcɖ5gٶmh
!>J6PAnZ//oUm/E|sd%{:d-bʃ]顈k
ȑaViB
s^})Vfy r0ښ]V؜I,枛Jg
Fhvk(
x	@pDSjs9"8,	ld蠄YؤPc ;6Ղ\UWv(Ċw=sp
.uV*#:ik3dgt\C@^ `m9Gz!>`i
(Dp@VDţVMA3*W@[)8\kN7nFϲT^GlaFYl޴8,x^?."DA.,`2:X;?r8nX %@|5EgAZP
X5h	A79L|TVN`T1$W0|'؀8`	zJ@";.^ `"dN,٨E2`kė"Y	`@3lvpD\at(٘ 7FA5Fٓen`!M|6le/v-iMZղֵ-mmKꖷpk\*to ]Z.wu]5o	v08]ZΌ6.eE\k[̭>;iO_Z'?u4/xn)9cƳAgāV1CX5nt!cISA9#:U
NDV.6̒(Dh	^p.C(19+fnx6G3lg"sA/Fi;ZǑqiMFM!o L$+};%hL'^2o6^uCٸn`HA
`,slbH0]M#Ӑ&T)Cq\"
1XOBlX^mЭnmL	v "azEO	$ oL`t4Nހ*!l@^a

h jr0h /
ς!m>BI.LPTZO^djOntnZv,X 		
A
ŐU !{נᝀMIz,p28.<p䰭
RNV.\bf.lrx~ 
@a"Z.Q)219,V@O	ǯ`zop
s@Qw1r,p8
,p3-V\obOhlop/td@kFY"n^nenN.x
).IrQ?y}1cG'Qp^`	!V(W371%BJVSSKEE6$+p77%1K&OwJIbu$\UQQQ+@
tEKP/!/q?k?3G3@ߴ81sH! < 3PPQXUX+R'UK-0K6?/eLs%o?G4N@t'ŀ2@BA5WbWWU]ו]!UR)UD5&/SY=FS7EFӔ0TGS@19T95	!uҵ]+bXU>ID;6E;^tS6/c4?U%m?
@ݔ88
4H@A
`3'bBbb/h62X5r#BY^_dLM7q48t8GH2UPpaa-\"hmhmi+Ui+vEAd/3760WTUak	11ߍtRAЖquE_WNTjUk`gkdB	IwsWמ7z8X=9cMcC)4E
"$5_uG
V`.eOevwfP,P!7m[M	ՀeS^CzS@	%:u7TgM1xv
7wUUv
`kqW`UUfYUqq
@ bO)ʘoxX)8ma@ ~Y٘adġ Q.YgY>VBeUw`f
LhAf+aڠmЖAsZZa4@ڡ#Z'Qa@R7`4wi`%/&ȡ.y`8qֻP `Y)j}s|@Zڪ!_	R18c[AL/C9kswCYGY` y"CXءazx7;aK|`

^
J`DHn5bZZv
8A{`;߀x :ty}˹}E9
T;>$o15C"Pۿ/`d:=s&@W@ğ	
0YSIqBv6Uckkzv N/`zCo9tZʫʯ˳\˷˻OQ
Ԁ&!=r@F|@6\*RaXLUe5pYcM?yW[c
Ry	
:`SN!	{,W \5`fkos]wu
Tւ	TH ԡ	d |,B@C	?N<'0x*tso@x2
:U@OD]ݸW@^^J V`@
ԀP!չ}%T`oBXѥ"@W8o#A8-yu% !^뷞KȢX!Q !0\JcL[ vIv;
wia[8~Uy_k\f@akgBb(bWKBb|ġN^,6b H 
Xe3W'vPa}g 6QYG@Hױd-lۺ}
Ltꔽ7Bd環	.#£
*T9"`
ab4+^̸G$K05qQ//bB62Td^DI!T)ċոY/D
_0?*Aޡ-С\!F+x-
lk'tKOэ![C1G,n@s&pDj;0BвS#Ř2b(DLAd|0#	\"U`.P^S*"AB
zrc`Fa
b
XC-p'0
ch
p?@D	07#z@DP h)XWC@)r:
C|'++p#$$b@?@G	f(AHG r,o_|4osG`	Q$hs &qV	~tjp7\;D38 u`2p0$bRp!lG|}on@v'Bګ 0PB?	*a3p>D/7"4'H_?
H 
0#@un
aC 0UPZA;1
0CH`iwB/
QFi$b)@
׏"KAX1XH
K	P
G	P2
SH4@LG$ht	\
g
q4P	s 
f0	h ivl' =	|'2@``WP	@@	```QUA}>	EexiEB~P/Pְ}gg}:`<ƀ~Caw0k`πp4wA7tBK1`r#re	cPA
2DAPww5GRJP	"P	5`	PPT`OP*	)05^ʡCJS0
)e?$5	t&`Z?
z`A	x0~83
xwp
DP!0PG`PEx7p	M$0|fXA|qp
	?xp@!RPz>p@&p	I	 
4
@ePGa}ъ)
@0`>!`p
"r$@@	q $QdA	~
`Y2
es
g0P0*D	`
nv
0p?!?Q@7>pUi>y
yf`^Pq֠X`eB:Od]@,f#_0O
(P	ynp3{d_P"(|y`~IDqu{;fPˉ`
Z@
TP]+`uKp
pg00 U riX
v D+P͠ P
; g`}{`@0	!T)>FP>QǠ	Zpp30 	@Y_`! l 3P>	İ

p
%lSy+-/1,d1pe	:=}5cIG\}`P.x	$yPS4
"L@'[,@
.ws*
P݊y}
̀ `G
0Xp
"cˠmwAp	.Toq0PtPpczLrYì%qgy`w
7	5ɡ	ven
p5pY㬒}QB
}@
mP	pV]pF dSo`oN<	!`}DGw4@
K( P<Өа$d$[0P<1	sMf@
+MOx@0@f4p29m
'x
>A
JPp:`	`Z|`VwP%@T0gMٕmٟٗٙٛٝ
ڡ-ڣMڥmڧکn;PK۸W;iiPK&AOEBPS/img/ccapp016.gif~>GIF89ap			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~,p	H*\ȰÇ#JHŋ3jȱǏ CIɓXɲK0I͛8sɳς*_
u	ѣH*]ʴOPmdСX8ʵׯ`Ò|'W
˶۷pLWHj[˷߿a-
oޕ(^̸ǐ#KL˘3kd{xҨS^ͺװ]M6C,~ĝw ,Nȓ+_μУ;ϢնEc%7pËOyԱ_VW{?OgϿ۲Bjg&~5Sπ#hVfy>?GY@ۀ],_u (cNLVYxw=͏@)DiH&L6{*gjtK1 p f2,vRڭ?7`\iHmMX3o/3[eA|}g
@c7+-A0Pڹ10ptu+]T@@`	˯n
BwqzN3)K8Rњ
RN{YH@1CVU>9ZOo/g菠B6^7הVAf6`6C5:o6:@8gFwDHQ#&&(!v|0v4Ao0.ڥaZgA(>@p}RlH*ZXbL٬+;H
,0] 6pI(w@.kH(O}EBLNEB(O
0uH&U+KX54 ")
*0Bg J=
k+#V:0gR0)0Iy+Z򲵅pz\CB0_U9n>A)u	m~z3O@pۖ6Cz̧>-Th	|ٛՄZ`^N$ĦxKLKu8qtZb8T2FxI\/":N_cQA#g0!.{`L2hN׌!T nւ
Q	>4p^@^uB^Cyyѐ'Mig^QN{Ӕ4\oA`3V!A$L)-S=9MK}A4LG/{n
:#v~_PcQ}.=]G[}킔y.HVhm5sפNԟ1׫ʦr&w'>gw3ס`0~ȳw-qGJ@5^,B_īZv%2򈗼J'5-)s8$oSX/5|'Rh{~,}Xx/|$/>n$o~N/<$ѯ~M\%I$'	o~?!Y_#/>mbo$72W-t{bAH({؀|8~h_XxmaK-m">w,6*xZ#"4};8UO&"E`s1]?h%V@4p8؁q^R6YQxSsqc*N5HQ>Y,Fx0'=hq(`#Cx؈(C!x3󈘘ȉ?EXQ'xrp;8Xx؋!>BXxȘʸhpFAc(2-d؍ =B8Jpkx1㳍8*HHa6(0fGC!Y`ؐ!؇׈;8& yy,ՑQ	7A-ٓF>901(Y2&)##DY?!Va
M8؁Bt&r9tYvyxz|ٗ~qYX9Pp)٘_@VQY!K9h	&:n9ai;`P)e.4ɔigX(3)_y3otK)M'jN/@@@PߠIB6ryћ14)'7SNAњkX%	QIhI؆B+߂)y8rŁ4A@A:9T䩒)
 	i@)Apoxo)9x&1s)[b+[	[X!r: 	WaTNCǂSRz	cE#PIg*0ڃ7%4ѡA;PQX6ABq=
TIv6nGm$>cG8
k7]b*d*Po* (]ĞQяDpCaTUDO\Bp&
%3BY#0p5W3>;@Ъn5
jvxz#5 :q=Q!#JA00
JDs*gqjݪUO-ʮgv;Wf*h+UhOc0hX jѦ+v
wts,1=PDzϐvt8Ҧ:DE$٠ ?a1Z&"PCEtcGc7UB$9V+'T:ރ5)11Q$|+'v1
?e/9[0ZA˴E@*:(J#0`"qJ*6ՁGw[.+>z>4C[)k, AڑiY4A>Y.8KP:b@3袻r,]⓽:w/5f;hjX1y+EN(ŸKKd7L䰯#iB|#T39nM=#1Pmw!!IBG!J_K5PG{:c,Z/:bG$
;[3igJ\rK!c~Q!ȓ|gJ@r,;Kȭ,Hڻʀ`J|
qi[DBz9iF.;j|=Bv@[B=FO&S:G*(|=N+,;N[=|;hO#(J

g

L:0ꩳȣу#[:
M믳sW,c}-r쑟h]t"nRs\F1N_H>\F-Qr8@,1:!
~HX
R7*t[ַq#Q3ƪa$1:ciFs]KECrt
BNlж1`A9aWB=s{3MeˉƇ
U8=m9֟yKa8VBF&}i]i]ĦhJA[]yy_ψHOH]MEK`DJ|!(ۗѩ#A:2?esHF=9r̳Y'">ѶK[m},	eC~Ĝ-;ܫ-qlEyd9S)̺QBs#m2[kʨb#o^<*%n^=Am&2`*(r0oR#Ƥ7ZTB>>2;)9'!1Gq,g!
]cAbEH4
Z$g[Aᣀ (OITu_Yt^N:N|-ZT*zo|-5ɯj(&,}@ .Y/i-qŚ2Ͼ#X? =;ۯ@;ņ5n1,!
I2[Jh˜l# @sZhgΓZ'/QN
P\	V(٩@
zƷ&X*eXyMC-L  @0[fݑ4
/^Ybȑ~OYҦ%
f-UmLpb >{zɸOY{o3=+pɈ"GxcQ>TȑE?,m6ί7>>*RݢHcQ92r%4@;~=O	]0dA+.̭#DD#/ņtEcIA08D#Vy@!+#=q>&>NO@4+rPDUtQFE4L6LBVBIJZ6o$M3-JGK5TTSr9UUXc.H9O;Z	2Ք
*T2=6HuYfUVYrvZjݳSI3[=IXP5qv]v6FWەwS
SQ4a15]\=HYzVwawa#߃)o`~W#rXNV]SVyEypecV[#3`MŕS2oFyTPzivizjj!0-Fzl6l~Q-~w5*Z2ՊhDžo|p7pN1lwq#-7>h"}
gd#!u.*d:}wI7Y5
h&׎ޫ>jܯW?grW( jAy@?ď6kHfm$*̿r_paw:F1pJ^vB''|C(
Ǒ*#+WdmګLC
S9Tf?,EsI<Ĕ!*Ub 0+œ<<cEh~~$$dXF!RrO"cA‰")pILf$d/vRx9AvhʺĒd%)QRM(eyK\xi)[R0_.&d(Lh.zYf4	g^S2fXMp0$灺oS:)s$'YO|J&g>{SR9P'	eI6TYD-ڐ$hQ:&hHMt-J]jTlLm*]ԤݬN}R4=
MZҒHQO@..uTBZU;Av\:ժdUk9ɶq
HWۄ^WZ)`	U,>ح>d;jX򲲙(f9{~(C[Z`JiVQվ6t
eu
\)|;+
>7nq^g]v]RG|/>[ލE}5/xʐ<|aorF'Xfp`GXpL`F~Tgp=aX!=`z嘉bสX-v1JQ,[xs56ۚcҘbk|[!yI9Eed%,uk$MyU^핱L,&˨򗷥e䎹e6s|,\5mX<E#G5mAg @snՊg@πs^ p
>|#-
,A|+pmfG0Ű~Q&7q߀A_Fk(MGH'63=W$:nM_|pDw&ܵ6F>We'19S-U
yD;03@(v_"iC@207?n`q|@^eĸΊZ
#'vc]7D'h{FPҗa] ^\Nڼ$@WLy7>(J$Q޹V{[@]$CGb~g8ܳ*'h8$u
#|oa	:
#sWrݭzw䃁'xqX29Cd0C`nu~x]߻Q~|MrYLgט
>;D	"'ȳk=s>l[Û>7㿏[C
1{*y>4X"ȑ){0<ɌX{GA?ˋA8A0p98l>¹k"[4Rr
8%4tBso 5\3XW8-vC*C*?CAD,-E7
`įo,E{DMDRF`QS˛oP̳Dy>зȀ4>c$0d)w̎8?+&D6_T_BH*I[HjHhĂ04jSI`p0)@QH:<|Ә̠IO;쯠h
xЊPˁA5BHuEv	$@#JJKBLR̗b̩rĻLLL̓LMM"͢2B͐R͠brMMM͎MMM:IN,N%f}g=hijUklmnEo%pqMr]steuvMw-xdeզc=|խ}~=wh8쫶I+{e s@:=[8>.yXيhXX>PXG@=!7æ\6Zh+<5H6M}-&{c۸}ˑwx^y4|7#3"󊈛3S*ZĚYEsJ+8	?C<ÿ[̓Hy}zJe|iB{jHjF^;*r5	sbL\\l\:!X8 ?ȏ=\(gH>1[B[f:Zx?ż:$ݞ鼁h˿ޝ7ٛC--=&刺q_T`A;uI"DGH_Z_cjߚC8C;tZTPbar```a"^2aBct]rRa͒ƢaȲ\ba\abba2BbY"bbrXbbRbbQNc"c2cNBRcbBrc㸒cB|c?c|c>Q=dDNdE^d,$d0TIdJndG(NSLOPάQRSnTU>VWXnYZV[\>]^&_`aNbc.dޫefƫghij*MVRMҪSqVk63$
9=
Mg3k.0gw~Qx63Ꚋvg/Bgtg‚:%%	flޏbV(G@`K#ť>ۏH=ċa
ݎ~gF(їFaz
鞹iңPԒ&aRZ֏fi}^,!

~fjj.dNk
S]ijPkkPtkUgIMfyκjqOVl̦ƾf͞.kl^nNbv>mٮ~^o[`k؞mf
8 x!En>
mn`nnnoo.o>oNofn
8}@m`b?@E6 6d3Шy,T8X+6&
0⽡op"xoڻ48%^% 5]G0P 6Ao,o	o؄p_Jk:˅:q
!Ȼ>Ȍ&9=ґ0a,_-W./osnXS):`p ?|V	?P&X$?/$i)M㵓M;	G6:]0`X9<1kl`w71^^cYo+>FP4b'v3JvQop 
[w6jC?DED`_$ȸS )H2kx*(	{z[)xY8xJxYXx*oA By6xkF?G*Bz_mi]$xhVy&8zyGrd_p2(_h|쯇7oֲitiyg
m`%|ؠy7o;~D$9>ϋl=? ~|#ՙ=PYp;/6PnAԉe@>{G
AH@~}gh$ʔ&j2?2gҬi&Μ:w'РB
_*2m)ԨR6}ir韮bǒ-IY\dGUjF>_`^L	E8 yu@0>A̯OpAp= `-hp/(aXFJ+_~{%[Y07‡/n8ڶ3o|껮"/@; v26,UU-֊;	 {5Hw'_m3};p@Iqe[l sr)"-pʭ7#5JUQW\y`1 ?Fu^n'7=H&]JIhj7@ 38@6)Г'[M	? `F͙	:(z(*(:(J*hgGZzpp؎!)jSDeB
h_EV'`w6hИF	HAͫz6Л BdE;l}RgK0az.骻.^fFw\TakҨR=Du.kkDEt"&k	He@s01F@b=q%g5|39\sWAA/T)$TI+4QK=5G|C@Pܯ}JFW5R7Msi69<Uҍ(	TCUdہ{ӂ~8?㦏A&VN9sឋ>:Q;Qy]ߧ>T~;vpzLOm;+<;|'
y's=ɿֽyL}_;?+@h>3mC|T_
f@
p@1uL	1
&doy!c(Ұ6!sm'!/¦k^Z"%2N|"y R#/^"(Nъf)S;@̺ahr(OeNt|J#C%Y.wBZ̀(=$fH`4Ƌ+I :
KIǥL0YJAṽ!K[Q8Xe2ւ9| IHX&qlm+׷Igh0{G $ɑAH!(iوYD>wAE/;3X&q~nJGύ䳘+
smNuhJ$HSbJ«NP4U,D<c%LΓX(VN4]-4˰X3׭uo^%,ex2)1wDg\EJij͕hJƘa]_}k.x&+p=VHr
+b^G|BQڋqDeIZN('M9ˈkDr/@H;+U:)RXzf~@6RXEoRl@`8}{Ў5L,f"j䧞/Sֿ>s8?_2)_,ID%OGUN1byB
M͵pEBKuN `$ THաrER&!|Q	 
ZdGQD
܈4s R`Kt;!&.!6>!FN!V^!;tC	`kX臍ӄcJVED}
U!
fM5Rć!$ZUxFpt$p)Q  bXmRWn=kDo|fU%fU&jE1EőE'F"zLba)&"bR|C2(NT<J_Hb)naEL#5V5^#6s,"$#qJH+B Ac!m#72G8F8?="r^:::B#c<}=BEG#J؆<>IF $cB1@Sod-E[;$N^GVEX$!Iv#WGCr12IrPUSl|Bxx;3e|\4WOKVN\\hh'Y܀C<àjJḦPvQʂV3IT"dYt^uT~UrKF T
+&A0KHBgze7l&CC@D
JXDk'LhV,`*NaRdb2&`XV,#\fZe&gLi_HF_jů]PeT`tgijeDF|dDy@`$4'U@'HKIZuWNl}Jx0[NvUfJW|DžԊ\yVMzEʃxw`:FLM
GjC|)8|ģƊV]kTpµ("סnR]	r()Џ\$LMcҥ3\Lǃ*|ȲL<ɵjR|g
:k萶MJE:Rd'~,5rLHȍViמ׾WU&ђ"@^֬NFż"Ja嚂@yUֆu؇9%Y]^h
0dMT,T\^eϘ=YڦVYPMّ~aaxMS""N,@+)G=1,E~j٬Z_)T(֡RHΎ>֫cl
=qLޛN.١UiN֛n Ol֟Œm~ۨ.m&Բ"Ej榚E=ViS֒r)mS$J`K
ldiHH->"E!֍%VJO񆮡n٪2EaDg׍=]uO#бWc9Em" m;o.Z.zrpAүʫ
wp`	Jlmo,-j0%b;s0
b?o
ߪ	pcװp&/
fh3d1GLqp_qk1 *7r1-1-11 l3 1Ug$!Na"r3r`Q	J%M2)_&%)krSGqͰ'ge-Q%k!/Q.SD'j޲1Q/.LLLGIRd>钾3m37w738s0E@h3o*%gJpTrJc=׳=3>i:^YYJSTRl3BSDl@CCTDԒdBgt`H=0F&*DL:GJN4LǴLU@;PKBDo>~>PK&AOEBPS/aoptim.htm

Tuning Oracle Text



7 Tuning Oracle Text


This chapter discusses how to improve your query and indexing performance. The following topics are covered:






7.1 Optimizing Queries for Response Time


By default, Oracle Text optimizes queries for throughput. This results in queries returning all rows in shortest time possible.


However, in many cases, especially in a Web application scenario, queries must be optimized for response time, when you are only interested in obtaining the first few hits of a potentially large hitlist in the shortest time possible.


The following sections describe some ways to optimize CONTAINS queries for response time:






7.1.1 Other Factors that Influence Query Response Time


There are other factors that can influence query response time such as:









7.1.2 Improved Response Time with FIRST_ROWS(n) Hint for ORDER BY Queries


When you need the first rows of an ORDER BY query, Oracle recommends that you use the cost-based FIRST_ROWS(n) hint.









Note:

As the FIRST_ROWS(n) hint is cost-based, Oracle recommends that you collect statistics on your tables before you use this hint. See .






You use the FIRST_ROWS(n) hint in cases where you want the first number (n) of rows in the shortest possible time. For example, consider the following PL/SQL block that uses a cursor to retrieve the first 10 hits of a query and uses the FIRST_ROWS(n) hint to optimize the response time:


declare
cursor c is 

select /* FIRST_ROWS(10) */ article_id from articles_tab
   where contains(article, 'Omophagia')>0 order "by pub_date desc;

begin



for i in c
loop
insert into t_s values(i.pk, i.col);
exit when c%rowcount > 11;
end loop;



end;
/



The cursor c is a SELECT statement that returns the rowids that contain the word omophagia in sorted order. The code loops through the cursor to extract the first 10 rows. These rows are stored in the temporary table t_s.


With the FIRST_ROWS(n) hint, the optimizer instructs the Text index to return rowids in score-sorted order when the cost of returning the top n hits is lower.


Without the hint, Oracle Database sorts the rowids after the Text index has returned all the rows in unsorted order that satisfy the CONTAINS predicate. Retrieving the entire result set this way takes time.


Because only the first 10 hits are needed in this query, using the hint results in better performance.









Note:

Use the FIRST_ROWS(n) hint when you need only the first few hits of a query. When you need the entire result set, do not use this hint as it might result in poor performance.









7.1.2.1 About the DOMAIN_INDEX_SORT Hint


You can also optimize for response time using the related DOMAIN_INDEX_SORT hint. Like FIRST_ROWS(n), when queries are optimized for response time, Oracle Text returns the first rows in the shortest time possible.


For example, you can use this hint as follows


select /*+ DOMAIN_INDEX_SORT */ pk, score(1), col from ctx_tab 
            where contains(txt_col, 'test', 1) > 0 order by score(1) desc;



However, this hint is only rule-based. This means that Oracle Text always chooses the index which satisfies the ORDER BY clause. This might result in sub-optimal performance for queries in which the CONTAINS clause is very selective. In these cases, Oracle recommends that you use the FIRST_ROWS(n) hint, which is fully cost-based.










7.1.3 Improved Response Time using Local Partitioned CONTEXT Index


Partitioning your data and creating local partitioned indexes can improve your query performance. On a partitioned table, each partition has its own set of index tables. Effectively, there are multiple indexes, but the results from each are combined as necessary to produce the final result set.


You create the CONTEXT index using the LOCAL keyword as follows:


CREATE INDEX index_name ON table_name (column_name) 
INDEXTYPE IS ctxsys.context
PARAMETERS ('...')
LOCAL



With partitioned tables and indexes, you can improve performance of the following types of queries:






7.1.3.1 Range Search on Partition Key Column


This is a query that restricts the search to a particular range of values on a column that is also the partition key. For example, consider a query on a date range:


SELECT storyid FROM storytab WHERE CONTAINS(story, 'oliver')>0 and pub_date BETWEEN '1-OCT-93' AND '1-NOV-93';



If the date range is quite restrictive, it is very likely that the query can be satisfied by only looking in a single partition.








7.1.3.2 ORDER BY Partition Key Column


This is a query that requires only the first n hits, and that the ORDER BY clause names the partition key. Consider an ORDER BY query on a price column to fetch the first 20 hits such as:


SELECT * FROM (



SELECT itemid FROM item_tab WHERE CONTAINS(item_desc, 'cd player')
  >0 ORDER BY price)
  WHERE ROWNUM < 20;





In this example, with the table partitioned by price, the query might only need to get hits from the first partition to satisfy the query.










7.1.4 Improved Response Time with Local Partitioned Index for Order by Score


Using the DOMAIN_INDEX_SORT hint on a local partitioned index might result in poor performance, especially when you order by score. This is because all hits to the query across all partitions must be obtained before the results can be sorted.


You can work around this by using an inline view when you use the DOMAIN_INDEX_SORT hint. Specifically, you can use the DOMAIN_INDEX_SORT hint to improve query performance on a local partitioned index under the following conditions:


  • 

    The text query itself including the order by SCORE() clause is expressed as an in-line view.
    

  • 

    The text query inside the in-line view contains the DOMAIN_INDEX_SORT hint.
    

  • 

    The query on the in-line view has ROWNUM predicate limiting number of rows to fetch from the view.
    



For example, if you have the following text query and local text index created on a partitioned table doc_tab:


     select doc_id, score(1) from doc_tab 
        where contains(doc, 'oracle', 1)>0 
        order by score(1) desc;



and you are only interested in fetching top 20 rows, you can rewrite the query to


     select * from 
          (select /*+ DOMAIN_INDEX_SORT */ doc_id, score(1) from doc_tab 
              where contains(doc, 'oracle', 1)>0 order by score(1) desc) 
      where rownum < 21;










See Also:

















7.2 Optimizing Queries for Throughput


Optimizing a query for throughput returns all hits in the shortest time possible. This is the default behavior.


The following sections describe how you can explicitly optimize for throughput.





7.2.1 CHOOSE and ALL ROWS Modes


By default, queries are optimized for throughput under the CHOOSE and ALL_ROWS modes. When queries are optimized for throughput, Oracle Text returns all rows in the shortest time possible.








7.2.2 FIRST_ROWS(n) Mode


In FIRST_ROWS(n) mode, the optimizer in Oracle Database optimizes for fast response time by having the Text domain index return score-sorted rows, if possible. This is the default behavior when you use the FIRST_ROWS(n) hint.


If you want to optimize for better throughput under FIRST_ROWS(n), you can use the DOMAIN_INDEX_NO_SORT hint. Better throughput means you are interested in getting all the rows to a query in the shortest time.


The following example achieves better throughput by not using the Text domain index to return score-sorted rows. Instead, Oracle Text sorts the rows after all the rows that satisfy the CONTAINS predicate are retrieved from the index:


select /*+ FIRST_ROWS(10) DOMAIN_INDEX_NO_SORT */ pk, score(1), col from ctx_tab 
            where contains(txt_col, 'test', 1) > 0 order by score(1) desc;










See Also:

Oracle Database Performance Tuning Guide for more information about the query optimizer and using hints such as FIRST_ROWS(n) and CHOOSE














7.3 Composite Domain Index (CDI) in Oracle Text


The Composite Domain Index feature of the Extensibility Framework in Oracle Database 11g, enables structured columns to be indexed by Oracle Text. Therefore, both text and one or more structured criteria can be satisfied by one single Oracle Text index row source. Performance for the following types of query are improved:


  • 

    Text query with structured criteria in the SQL WHERE clause.
    

  • 

    Text query with structured ORDER BY criteria.
    

  • 

    Combination of both of the previous two query types.
    



As with concatenated btree indexes or bitmap indexes, applications will experience slow-down in DML performance as the number of FILTER BY and ORDER BY columns increases. Where SCORE-sort push-down is optimized for response time, the structured sort or combination of SCORE and structured sort push-down are also optimized for response time, and not for throughput. However, using DOMAIN_INDEX_SORT or FIRST_ROWS(n) hints to force the sort to be pushed into CDI while fetching the entire hitlist may result in poor query response time.





7.3.1 Performance Tuning with CDI


Support for mapping a FILTER BY column to MDATA enables query performance to be optimized for equality searches by restricting supported functionality of RANGE and LIKE. However, mapping a FILTER BY column to MDATA is not recommended if the FILTER BY column contains sequential values, or has very high cardinality. Doing so can result in a very long and narrow $I table and reduced $X performance. One example of such a sequential column might be one that uses DATE stamp. For such sequential columns, mapping to SDATA is recommended.


The following hints can be used to push or not push the SORT and FILTER BY predicates into the CDI:


  • 

    DOMAIN_INDEX_SORT. The query optimizer will try to push the applicable sorting criteria into the specified composite domain index.
    

  • 

    DOMAIN_INDEX_NO_SORT. The query optimizer will try NOT to push sorting criteria into the specified composite domain index.
    

  • 

    DOMAIN_INDEX_FILTER(table name index name). The query optimizer will try to push the applicable FILTER BY predicate(s) into the specified composite domain index.
    

  • 

    DOMAIN_INDEX_NO_FILTER(table name index name). The query optimizer will not try to push the applicable FILTER BY predicate(s) into the specified composite domain index.
    





Example 7-1 Performance Tuning a Text Query with CDI Hints


The following example performs an optimized query on the table books.


SELECT bookid, pub_date, source FROM
  (SELECT /*+ domain_index_sort domain_index_filter(books books_ctxcdi) */ bookid, pub_date, source
      FROM books
      WHERE CONTAINS(text, 'aaa',1)>0 AND bookid >= 80
      ORDER BY PUB_DATE desc nulls last, SOURCE asc  nulls last, score(1) desc)
 WHERE rownum < 20;











Note:

The domain_index_filter hint does not force the query optimizer to use CDI. Instead, if the cost-based optimizer chooses to use the CDI, then it should also push the filter predicate into the index. To force the query optimizer to choose CDI index, you additionally need to use the INDEX hint.














7.4 Solving Index and Query Bottlenecks Using Tracing


Oracle Text includes a tracing facility that enables you to identify bottlenecks in indexing and querying.


Oracle Text provides a set of predefined traces. Each trace is identified by a unique number. There is also a symbol in CTX_OUTPUT for this number.


Each trace measures a specific numeric quantity—for instance, the number of $I rows selected during text queries.


Traces are cumulative counters, so usage is as follows:


  1. 

    The user enables a trace.
    

  2. 

    The user performs one or more operations. Oracle Text measures activities and accumulates the results in the trace.
    

  3. 

    The user retrieves the trace value, which is the total value across all operations done in step 2.
    

  4. 

    The user resets the trace to 0.
    

  5. 

    The user starts over at Step 2.
    



So, for instance, if in step 2 the user runs two queries, and query 1 selects 15 rows from $I, and query 2 selects 17 rows from $I, then in step 3 the value of the trace would be 32 (15 + 17).


Traces are associated with a session—they can measure operations that take place within a single session, and, conversely, cannot make measurements across sessions.


During parallel sync or optimize, the trace profile will be copied to the slave sessions if and only if tracing is currently enabled. Each slave will accumulate its own traces and implicitly write all trace values to the slave logfile before termination.









7.5 Using Parallel Queries


In general, parallel queries are optimal for DSS, OLAP, or analytical systems with large data collection, multiple CPUs with a low number of concurrent users, or parallelized across Oracle Real Application Clusters (Oracle RAC) nodes.


Oracle Text supports parallel queries as follows:






7.5.1 Parallel Queries on a Local Context Index


Parallel query refers to the parallelized processing of a local CONTEXT index. Based on the parallel degree of the index and various system attributes, Oracle determines the number of parallel query slaves to be spawned to process the index. Each parallel query slave processes one or more index partitions. This is the default query behavior for local indexes created in parallel.


However, for heavily loaded systems with high numbers of concurrent users, query throughput will generally be worse with parallel query because top N hits can usually be satisfied by the first few partitions, if the query is run serially. For example, typical top N text queries with an ORDER BY partition key column, such as:


select * from (
        select story_id from stories_tab where contains(...)>0 order by 
publication_date desc)
    where rownum <= 10;



will generally perform worse with a parallel query.


You can disable parallel querying after a parallel index operation with an ALTER INDEX statement as follows:


Alter index <text index name> NOPARALLEL;
Alter index <text index name> PARALLEL 1;



You can also enable or increase the parallel degree by specifying:


Alter index <text index name> paralllel < parallel degree >;







7.5.2 Parallelizing Queries Across Oracle RAC Nodes


When considering whether to use Oracle Real Application Clusters (Oracle RAC) to improve Oracle Text performance, it is essential to understand which performance issues that you are trying to solve. Oracle RAC is a great solution for improving query throughput. If you can get good performance from Oracle Text with a light query load, then you can expect to get excellent scalability from Oracle RAC as the query load increases.


Further improvements in Oracle Text performance in an Oracle RAC environment may be achieved by physically partitioning the text data and text indexes (using local partitioned indexes), and ensuring that partitions are handled by separate Oracle RAC nodes. This way, you avoid duplication of the cache contents across multiple nodes and, therefore, maximize the benefit of Oracle RAC cache fusion.


In Oracle 10g Release 1, each Oracle Text index partition must be forced into a separate database file when the index is created. This enables the use of the "re-mastering" feature in Oracle RAC to force database file affinity, in which each node concentrates on a particular database file and, therefore, a particular Oracle Text index partition.


In Oracle 10g Release 2 and forward, Oracle supports database object-level affinity, which makes it much easier to allocate index objects ($I and $R tables) to particular nodes.


While Oracle RAC offers solutions for improving query throughput and performance, is not a "magic bullet," and it will not necessarily enable you to continue to get the same performance improvements as you scale up the data volumes. You are more likely to see improvements by increasing the amounts of memory available to the SGA cache, or by partitioning your data in such a way that queries will normally not need to hit all of the partitions of a table in order to provide the required set of query results.










7.6 Tuning Queries with Blocking Operations


Issuing a query with more than one predicate can cause a blocking operation in the execution plan. For example, consider the following mixed query:


select docid from mytab where contains(text, 'oracle', 1) > 0 
  AND colA > 5 
  AND colB > 1 
  AND colC > 3; 



Assume that all predicates are unselective and colA, colB, and colC have bitmap indexes. The cost-based optimizer in Oracle Database chooses the following execution plan:


TABLE ACCESS BY ROWIDS
  BITMAP CONVERSION TO ROWIDS
    BITMAP AND
      BITMAP INDEX COLA_BMX
      BITMAP INDEX COLB_BMX
      BITMAP INDEX COLC_BMX
      BITMAP CONVERSION FROM ROWIDS
        SORT ORDER BY
          DOMAIN INDEX MYINDEX



Because the BITMAP AND is a blocking operation, Oracle Text must temporarily save the rowid and score pairs returned from the Oracle Text domain index before running the BITMAP AND operation.


Oracle Text attempts to save these rowid and score pairs in memory. However, when the size of the result set containing these rowid and score pairs exceeds the SORT_AREA_SIZE initialization parameter, Oracle Text spills these results to temporary segments on disk.


Because saving results to disk causes extra overhead, you can improve performance by increasing the SORT_AREA_SIZE parameter using ALTER SESSION as follows:


alter session set SORT_AREA_SIZE = <new memory size in bytes>;



For example, to set the buffer to approximately 8 megabytes, enter:


alter session set SORT_AREA_SIZE = 8300000;










See Also:

Oracle Database Performance Tuning Guide and Oracle Database Reference for more information on SORT_AREA_SIZE












7.7 Frequently Asked Questions About Query Performance


This section answers some of the frequently asked questions about query performance.





7.7.1 What is Query Performance?


Answer: There are generally two measures of query performance:


  • 

    Response time, the time to get an answer to an individual query, and
    

  • 

    Throughput, the number of queries that can be run in any time period; for example, queries each second).
    



These two are related, but are not the same. In a heavily loaded system, you normally want maximum throughput, whereas in a relatively lightly loaded system, you probably want minimum response time. Also, some applications require a query to deliver all its hits to the user, whereas others might only require the first 20 hits from an ordered set. It is important to distinguish between these two scenarios.








7.7.2 What is the fastest type of text query?


Answer: The fastest type of query will meet the following conditions:


  • 

    Single CONTAINS clause
    

  • 

    No other conditions in the WHERE clause
    

  • 

    No ORDER BY clause at all
    

  • 

    Only the first page of results is returned (for example, the first 10 or 20 hits).
    









7.7.3 Should I collect statistics on my tables?


Answer: Yes. Collecting statistics on your tables enables Oracle Text to do cost-based analysis. This helps Oracle Text choose the most efficient execution plan for your queries.


If your queries are always pure text queries (no structured predicate and no joins), you should delete statistics on your Oracle Text index.









See Also:














7.7.4 How does the size of my data affect queries?


Answer: The speed at which the text index can deliver ROWIDs is not affected by the actual size of the data. Text query speed will be related to the number of rows that must be fetched from the index table, number of hits requested, number of hits produced by the query, and the presence or absence of sorting.








7.7.5 How does the format of my data affect queries?


Answer: The format of the documents (plain ASCII text, HTML or Microsoft Word) should make no difference to query speed. The documents are filtered to plain text at indexing time, not query time.


The cleanliness of the data will make a difference. Spell-checked and sub-edited text for publication tends to have a much smaller total vocabulary (and therefore size of the index table) than informal text such as e-mails, which will contain many spelling errors and abbreviations. For a given index memory setting, the extra text takes up more memory, which can lead to more fragmented rows than in the cleaner text, which can adversely affect query response time.








7.7.6 What is a functional versus an indexed lookup?


Answer: There are two ways the kernel can query the text index. In the first and most common case, the kernel asks the text index for all the rowids that satisfy a particular text search. These rowids are returned in batches. In the second, the kernel passes individual rowids to the text index, and asks whether that particular rowid satisfies a certain text criterion.


The second is known as a functional lookup, and is most commonly done where there is a very selective structured clause, so that only a few rowids must be checked against the text index. An example of a search where a functional lookup may be used:


SELECT ID, SCORE(1), TEXT FROM MYTABLE



WHERE START_DATE = '21 Oct 1992'         <- highly selective
AND CONTAINS (TEXT, 'commonword') > 0    <- unselective



Functional invocation is also used for text query ordered by structured column (for example date, price) and text query is unselective.








7.7.7 What tables are involved in queries?


Answer: All queries look at the index token table. Its name has the form DR$indexname$I. This contains the list of tokens (column TOKEN_TEXT) and the information about the row and word positions where the token occurs (column TOKEN_INFO).


The row information is stored as internal DOCID values. These must be translated into external ROWID values. The table used for this depends on the type of lookup: For functional lookups, the $K table, DR$indexname$K, is used. This is a simple Index Organized Table (IOT) which contains a row for each DOCID/ROWID pair.


For indexed lookups, the $R table, DR$indexname$R, is used. This holds the complete list of ROWIDs in a BLOB column.


Hence we can easily find out whether a functional or indexed lookup is being used by examining a SQL trace, and looking for the $K or $R tables.









Note:

These internal index tables are subject to change from release to release. Oracle recommends that you do not directly access these tables in your application.












7.7.8 Does sorting the results slow a text-only query?


Answer: Yes, it certainly does.


If there is no sorting, then Oracle Text can return results as it finds them, which is quicker in the common case where the application needs to display only a page of results at a time.








7.7.9 How do I make an ORDER BY score query faster?


Answer: Sorting by relevance (SCORE(n)) can be extremely quick if the FIRST_ROWS(n) hint is used. In this case, Oracle Text performs a high speed internal sort when fetching from the text index tables.


An example of such a query:


              SELECT /*+ FIRST_ROWS(10) */ ID, SCORE(1), TEXT FROM mytable
                WHERE CONTAINS (TEXT, 'searchterm', 1) > 0
                ORDER BY SCORE(1) DESC;



Note that for this to work efficiently, there must be no other criteria in the WHERE clause other than a single CONTAINS.








7.7.10 Which Memory Settings Affect Querying?


Answer: For querying, you want to strive for a large system global area (SGA). You can set these parameters related to SGA in your Oracle Database initialization file. You can also set these parameters dynamically.


The SORT_AREA_SIZE parameter controls the memory available for sorting for ORDER BY queries. You should increase the size of this parameter if you frequently order by structured columns.









See Also:















7.7.11 Does out of line LOB storage of wide base table columns improve performance?


Answer: Yes. Typically, a SELECT statement selects more than one column from your base table. Because Oracle Text fetches columns to memory, it is more efficient to store wide base table columns such as LOBs out of line, especially when these columns are rarely updated but frequently selected.


When LOBs are stored out of line, only the LOB locators need to be fetched to memory during querying. Out of line storage reduces the effective size of the base table making it easier for Oracle Text to cache the entire table to memory. This reduces the cost of selecting columns from the base table, and hence speeds up text queries.


In addition, having smaller base tables cached in memory enables more index table data to be cached during querying, which improves performance.








7.7.12 How can I make a CONTAINS query on more than one column faster?


Answer: The fastest type of query is one where there is only a single CONTAINS clause, and no other conditions in the WHERE clause.


Consider the following multiple CONTAINS query:


              SELECT title, isbn FROM booklist
                WHERE CONTAINS (title, 'horse') > 0
                  AND CONTAINS (abstract, 'racing') > 0



We can obtain the same result with section searching and the WITHIN operator as follows:


              SELECT title, isbn FROM booklist
                WHERE CONTAINS (alltext, 
                  'horse WITHIN title AND racing WITHIN abstract')>0



This query completes more quickly. To use a query like this, we must copy all the data into a single text column for indexing, with section tags around each column's data. This can be done with PL/SQL procedures before indexing, or by making use of the USER_DATASTORE datastore during indexing to synthesize structured columns with the text column into one document.








7.7.13 Is it OK to have many expansions in a query?


Answer: Each distinct word used in a query requires at least one row to be fetched from the index table. It is therefore best to keep the number of expansions down as much as possible.


You should not use expansions such as wild cards, thesaurus, stemming and fuzzy matching unless they are necessary to the task. In general, a few expansions (for example, 10 to 20) does not cause difficulty, but avoid having large numbers of explansions (80 or 100) in a query. The query feedback mechanism can be used to determine the number of expansions for any particular query expression.


In addition for wildcard and stem queries, you can remove the cost of term expansion from query time to index time by creating prefix, substring or stem indexes. Query performance increases at the cost of longer indexing time and added disk space.


Prefix and substring indexes can improve wildcard performance. You enable prefix and substring indexing with the BASIC_WORDLIST preference. The following example sets the wordlist preference for prefix and substring indexing. For prefix indexing, it specifies that Oracle Text create token prefixes between 3 and 4 characters long:


begin 



ctx_ddl.create_preference('mywordlist', 'BASIC_WORDLIST'); 
ctx_ddl.set_attribute('mywordlist','PREFIX_INDEX','TRUE');
ctx_ddl.set_attribute('mywordlist','PREFIX_MIN_LENGTH', '3');
ctx_ddl.set_attribute('mywordlist','PREFIX_MAX_LENGTH', '4');
ctx_ddl.set_attribute('mywordlist','SUBSTRING_INDEX', 'YES');



end



You enable stem indexing with the BASIC_LEXER preference:


begin



ctx_ddl.create_preference('mylex', 'BASIC_LEXER');
ctx_ddl.set_attribute ( 'mylex', 'index_stems', 'ENGLISH');



end;







7.7.14 How can local partition indexes help?


Answer: You can create local partitioned CONTEXT indexes on partitioned tables. This means that on a partitioned table, each partition has its own set of index tables. Effectively, there are multiple indexes, but the results from each are combined as necessary to produce the final result set.


The index is created using the LOCAL keyword:


CREATE INDEX index_name ON table_name (column_name) 
INDEXTYPE IS ctxsys.context
PARAMETERS ('...')
LOCAL



With partitioned tables and local indexes, you can improve performance of the following types of CONTAINS queries:









7.7.15 Should I query in parallel?


Answer: It depends on system load and server capacity. Even though parallel querying is the default behavior for indexes created in parallel, it usually results in degrading overall query throughput on heavily loaded systems.


In general, parallel queries are particularly appropriate for DSS or analytical systems with large data collections, multiple CPUs, and low number of concurrent users.









7.7.16 Should I index themes?


Answer: Indexing theme information with a CONTEXT index takes longer and also increases the size of your index. However, theme indexes enable ABOUT queries to be more precise by using the knowledge base, if available. If your application uses ABOUT queries heavily, it might be worthwhile to create a theme component to the index, despite the extra indexing time and extra storage space required.









7.7.17 When should I use a CTXCAT index?


Answer: CTXCAT indexes work best when text is in small chunks, maybe a few lines maximum, and searches need to restrict or sort the result set according to certain structured criteria, usually numbers or dates.


For example, consider an on-line auction site. Each item for sale has a short description, a current bid price, and dates for the start and end of the auction. A user might want to see all the records with antique cabinet in the description, with a current bid price less than $500. Because he is particularly interested in newly posted items, he wants the results sorted by auction start time.


Such a search is not always efficient with a CONTAINS structured query on a CONTEXT index, where the response time can vary significantly depending on the structured and CONTAINS clauses. This is because the intersection of structured and CONTAINS clauses or the ordering of text query is computed during query time.


By including structured information such as price and date within the CTXCAT index, query response time is always in an optimal range regardless of search criteria. This is because the interaction between text and structured query is pre-computed during indexing. Consequently query response time is optimum.








7.7.18 When is a CTXCAT index NOT suitable?


Answer: There are differences in the time and space needed to create the index. CTXCAT indexes take a bit longer to create and use considerably more disk space than CONTEXT indexes. If you are tight on disk space, you should consider carefully whether CTXCAT indexes are appropriate for you.


With respect to query operators, you can now use the richer CONTEXT grammar in CATSEARCH queries with query templates. The older restriction of a single CATSEARCH query grammar no longer holds.








7.7.19 What optimizer hints are available, and what do they do?


Answer: The optimizer hint INDEX(table column) can be used in the usual way to drive the query with a text or b-tree index.


You can also use the NO_INDEX(table column) hint to disable a specific index.


Additionally, the FIRST_ROWS(n) hint has a special meaning for text queries and should be used when you need the first n hits to a query. Use of the DOMAIN_INDEX_SORT hint in conjunction with ORDER BY SCORE(n) DESC tells the Oracle optimizer to accept a sorted set from the text index, and not to do a further sort.











7.8 Frequently Asked Questions About Indexing Performance


This section answers some of the frequently asked questions about indexing performance.





7.8.1 How long should indexing take?


Answer: Indexing text is a resource-intensive process. The speed of indexing will depend on the power of the hardware involved. Indexing speed depends on CPU and I/O capacity. Given sufficient I/O capacity to read in the original data and write out index entries, then CPU will be the limiting factor.


Tests with Intel x86 (Core 2 architecture, 2.5GHz) CPUs have shown that Oracle Text can index around 100GB of text per CPU core, per day. This would be expected to increase as CPU clock speeds increase and/or CPU architectures become more efficient.


Other factors such as your document format, location of your data, and the calls to user-defined datastores, filters, and lexers can have an impact on your indexing speed.








7.8.2 Which index memory settings should I use?


Answer: You can set your index memory with the system parameters DEFAULT_INDEX_MEMORY and MAX_INDEX_MEMORY. You can also set your index memory at run time with the CREATE INDEX memory parameter in the parameter string.


You should aim to set the DEFAULT_INDEX_MEMORY value as high as possible, without causing paging.


You can also improve Indexing performance by increasing the SORT_AREA_SIZE system parameter.


Oracle recommends that you use a large index memory setting. Large settings, even up to hundreds of megabytes, can improve the speed of indexing, and reduce the fragmentation of the final indexes. However, if you set the index memory setting too high, then memory paging can occur that will reduce indexing speed.


With parallel indexing, each stream requires its own index memory. When dealing with very large tables, you can tune your database system global area (SGA) differently for indexing and retrieval. For querying, you want to get as much information cached in the system global area's (SGA) block buffer cache as possible. So you should allocate a large amount of memory to the block buffer cache. But this will not make any difference to indexing, so you would be better off reducing the size of the SGA to make more room for a large index memory settings during indexing.


You set the size of SGA in your Oracle Database initialization file.









See Also:















7.8.3 How much disk overhead will indexing require?


Answer: The overhead, the amount of space needed for the index tables, varies between about 50% of the original text volume and 200%. Generally, the larger the total amount of text, the smaller the overhead, but many small records will use more overhead than fewer large records. Also, clean data (such as published text) will require less overhead than dirty data such as e-mails or discussion notes, because the dirty data is likely to include many unique words from mis-spellings and abbreviations.


A text-only index is smaller than a combined text and theme index. A prefix and substring index makes the index significantly larger.








7.8.4 How does the format of my data affect indexing?


Answer: You can expect much lower storage overhead for formatted documents such as Microsoft Word files because such documents tend to be very large compared to the actual text held in them. So 1GB of Word documents might only require 50MB of index space, whereas 1GB of plain text might require 500MB, because there is ten times as much plain text in the latter set.


Indexing time is less clear-cut. Although the reduction in the amount of text to be indexed will have an obvious effect, you must balance this out against the cost of filtering the documents with the AUTO_FILTER filter or other user-defined filters.








7.8.5 Can parallel indexing improve performance?


Answer: Parallel indexing can improve index performance when you have a large amount of data, and have multiple CPUs.


You use the PARALLEL keyword when creating the index:


CREATE INDEX index_name ON table_name (column_name) 
INDEXTYPE IS ctxsys.context PARAMETERS ('...') PARALLEL 3;



This will create the index with up to three separate indexing processes depending on your resources.


Parallel indexing can also be used to create local partitioned indexes on partitioned tables. However, indexing performance only improves when you have multiple CPUs.









Note:

Using PARALLEL to create a local partitioned index enables parallel queries. (Creating a non-partitioned index in parallel does not turn on parallel query processing.)

Parallel querying degrades query throughput especially on heavily loaded systems. Because of this, Oracle recommends that you disable parallel querying after parallel indexing. To do so, use ALTER INDEX NOPARALLEL.














7.8.6 How can I improve index performance for creating local partitioned index?


Answer: When you have multiple CPUs, you can improve indexing performance by creating a local index in parallel. There are two ways to index in parallel:


You can create a local partitioned index in parallel in two ways:


  • 

    Use the PARALLEL clause with the LOCAL clause in CREATE INDEX.In this case, the maximum parallel degree is limited to the number of partitions you have.
    

  • 

    Create an unusable index first, then run the DBMS_PCLXUTIL.BUILD_PART_INDEX utility. This method can result in a higher degree of parallelism, especially if you have more CPUs than partitions.
    



The following is an example for the second method. In this example, the base table has three partitions. We create a local partitioned unusable index first, the run the DBMS_PCLUTIL.BUILD_PART_INDEX, which builds the 3 partitions in parallel (inter-partition parallelism). Also inside each partition, index creation is done in parallel (intra-partition parallelism) with a parallel degree of 2.


create index tdrbip02bx on tdrbip02b(text) 
indextype is ctxsys.context local (partition tdrbip02bx1, 
                                   partition tdrbip02bx2, 
                                   partition tdrbip02bx3) 
unusable; 

exec dbms_pclxutil.build_part_index(3,2,'TDRBIP02B','TDRBIP02BX',TRUE); 







7.8.7 How can I tell how much indexing has completed?


Answer: You can use the CTX_OUTPUT.START_LOG procedure to log output from the indexing process. Filename will normally be written to $ORACLE_HOME/ctx/log, but you can change the directory using the LOG_DIRECTORY parameter in CTX_ADM.SET_PARAMETER.









See Also:

Oracle Text Reference to learn more about using this procedure














7.9 Frequently Asked Questions About Updating the Index


This section answers some of the frequently asked questions about updating your index and related performance issues.





7.9.1 How often should I index new or updated records?


Answer: The less often you run reindexing with CTX_DLL.SYNC_INDEX, the less fragmented your indexes will be, and the less you will need to optimize them.


However, this means that your data will become progressively more out of date, which may be unacceptable for your users.


Overnight indexing is acceptable for many systems. In this case, data that is less than a day old is not searchable. Other systems use hourly, ten minute, or five minute updates.









See Also:















7.9.2 How can I tell when my indexes are getting fragmented?


Answer: The best way is to time some queries, run index optimization, then time the same queries (restarting the database to clear the SGA each time, of course). If the queries speed up significantly, then optimization was worthwhile. If they don't, you can wait longer next time.


You can also use CTX_REPORT.INDEX_STATS to analyze index fragmentation.









See Also:















7.9.3 Does memory allocation affect index synchronization?


Answer: Yes, the same way as for normal indexing. There are often far fewer records to be indexed during a synchronize operation, so it is not usually necessary to provide hundreds of megabytes of indexing memory.










PK֍A-PK&AOEBPS/img_text/ccapp018.htm-

Description of the illustration ccapp018.eps

This illustration shows how a classification application can work. On the far left are three documents, one from a database, one from a file system, and one from the Web. These three are fed into the Document Classification Application as part of the Document Stream. From the Document Classification Application go two arrows. The first, a SQL MATCHES query, goes to a database ("Database A"), which includes a rules table and a CTXRULE index. The second arrow, labeled "Perform Action," splits off in two. One branch goes off to an icon of a letter, labeled "Email user." The other goes off to a second database ("Database B"), and is labeled "Classify Document."


PKX
M+2-PK&AOEBPS/img_text/search01b.htmd

Description of the illustration search01b.gif

This screen shot shows the text query application in a web browser. It displays a box for typing in a search term, as well as a button labeled "Search." The user has typed the word "pet" into the input area.


PKw)idPK&AOEBPS/img_text/ccapp019.htm

Description of the illustration ccapp019.eps

This illustration shows two columns of the Auction Table index, title and price, being copied into the CTXCAT index.


PK8}
PK&AOEBPS/img_text/ccapp016.htmo

Description of the illustration ccapp016.eps

This illustration shows a generalized flow of a catalog query application. At the top is a box labeled "Enter Query," with a user, well, entering a query. Arrows lead down to two boxes, also depicting users. One is labeled "Text Component 'CD Player'" and the other is labeled "Structured Component 'Order By Price'." Arrows lead from both of these boxes to a box labeled "Execute Catsearch Query (CATSEARCH)," and an arrow leads from this box down to one labeled "Show Results." From "Show Results" an arrow leads to another box with a user, and this box is labeled "User Browses Results." Two arrows extend from this box: one runs back up to the first box, "Enter Query," and the other goes down to the "User Purchases Item" box.


PK#ĜtoPK&AOEBPS/img_text/ccapp014.htmq

Description of the illustration ccapp014.eps

This illustration shows a generalized schema of a text query application. It shows a context index and a document table as part of the database, and a two-way arrow between the database and a text query application, representing a SQL CONTAINS query.


PK&PK&AOEBPS/img_text/pethilitb.htm;

Description of the illustration pethilitb.gif

This screenshot shows the document displayed in Figure 5-1 with each occurence of the word "pet" italicized and highlighted in red.


PK~|@;PK&AOEBPS/img_text/pet01b.htm

Description of the illustration pet01b.gif

This screen shot shows a sample HTML document to which we can apply various document services, such as highlighting and gisting.


PKCCPK&AOEBPS/img_text/ccapp012.htm{

Description of the illustration ccapp012.eps

This illustration shows how the browser calls the PSP-stored procedure.


On the far left is a picture of a browser, with the caption "Browser calls PSP-stored procedure with URL. A double-headed arrow, labeled http://my_machine:7777/mypath/search_html, connects the browser to a server, which is captioned "Web server maps URLs to PSP-stored procedure." A second double arrow runs between the web server and the database. The database contains two boxes, one labeled "PL/SQL Gateway" and the other labeled "PSP-stored Procedure," and is captioned "Database stores compiled PSP files as PL/SQL stored procedures." A table (search_table) and an index (idx_search_table) are also shown as part of the database.


PK8PK&AOEBPS/img_text/ccapp010.htm

Description of the illustration ccapp010.eps

This illustration shows how a table called "Auction Table" with the following columns: itetm_id, title, category_id, price, and bid_close. The title and price columns are linked by an arrow to form Sub-index A, while the title, price, and bid_close columns are linked to form Sub-index B. Arrows from the table show the two sub-indexes forming part of the CTXCAT index.


PKSu*
PK&AOEBPS/img_text/petthemeb.htmx

Description of the illustration petthemeb.gif

This illustration shows a query application returning a list of the top 50 themes for a document. The top theme is "freedom", which has a theme weight of 30. The next is "leashes", which has a theme weight of 29. This continues down the list.


PK/<PK&AOEBPS/img_text/ccapp017.htmq

Description of the illustration ccapp017.eps

This illustration shows a generalized schema of a catalog query application. It shows a CTXCAT index and a document table as part of the database, and a two-way arrow between the database and a catalog application, representing a SQL CATSEARCH query.


PK7'PK&AOEBPS/img_text/ccapp015.htm

Description of the illustration ccapp015.eps

This illustration shows the flow of a query application. At the top of the illustration is the first of five boxes. It is labeled "Enter Query" and shows a user, to indicate user action. An arrow leads down to a second box labeled "Execute CONTAINS Query" and then from this second box to a third box labeled "Present Hitlist." An arrow connects this box to a fourth box, with a user pictured, labelled "Select from Hitlist." From this box lead two arrows: one goes back to the first box, "Enter Query," while the other leads to the fifth and final box, "Present Document (CTX_DOC.HIGHLIGHT) ."


PK0PK&AOEBPS/img_text/petgist1b.htmB

Description of the illustration petgist1b.gif

This illustration shows a query application presenting a gist for a document. In this case, the application has selected the single paragraph that best sums up the document.


PKGBPK&AOEBPS/img_text/search02b.htm(

Description of the illustration search02b.gif

This screen shot shows the results returned by the query on the word "pet" shown in Figure A-1. Six documents containing the word "pet" are shown. Next to the title of each document are four links, labeled "HTML," "Highlight," "Theme," and "Gist." These links are described in the text.


PK+PK&A OEBPS/img_text/qcatwiz1_newb.htm!

Description of the illustration qcatwiz1_newb.gif

This illustration is a screenshot of the Catalog Search application, showing matches displaying matching product names and their prices.


PK$F&!PK&AOEBPS/img_text/ccapp002.htmY

Description of the illustration ccapp002.eps

This illustration shows the different ways that text tables can be populated, as described in the accompanying text. At the top, documents are shown to be directly stored in the text table. In the middle, the text table contains references to file paths (for example, /my_path/my_system/doc1.doc). The third level shows a text table that contains URLs to documents (for example, http://www.mysite.com/mydoc1.html).


PKK^YPK&AOEBPS/img_text/ccapp011.htm

Description of the illustration ccapp011.eps

This illustration depicts the Oracle Text indexing process. The process is described in the text; following is a description of the illustration.


On the far left, documents from three different sources (the Internet, an O/S file system, and a database) stream into datastore. These are then passed into a Filter, where they emerge as marked-up text. The marked-up text goes then goes to the Sectioner.


From the Sectioner, two paths emerge: the documents go to the Lexer, where they are converted to tokens, then sent to the Indexing Engine. Meanwhile, the markup information leaves the Sectioner and goes directly to the Indexing Engine.


From the Indexing Engine, one arrow goes down to the database with an Oracle Text index. Another arrow, a two-way arrow, goes between the Indexing Engine and a Wordlist, while a second two-way arrow goes between the Indexing Engine and a Stoplist.


PKv8#PK&AOEBPS/quicktour.htm3m̒

Getting Started with Oracle Text



2 Getting Started with Oracle Text


This chapter discuses the following topics:






2.1 Overview of Getting Started with Oracle Text


This chapter provides basic information about how to create an Oracle Text developer user account, and how to build simple text query and catalog applications. It also provides information about basic SQL statements for each type of application to load, index, and query tables.


More complete application examples are given in the Appendices. To learn more about building document classification applications, see Chapter 6, "Classifying Documents in Oracle Text".









Note:

The SQL> prompt has been omitted in this chapter, in part to improve readability and in part to make it easier for you to cut and paste text.












2.2 Creating an Oracle Text User


Before you can create Oracle Text indexes and use Oracle Text PL/SQL packages, you need to create a user with the CTXAPP role. This role enables you to do the following:


  • 

    Create and delete Oracle Text indexing preferences
    

  • 

    Use the Oracle Text PL/SQL packages
    



To create an Oracle Text application developer user, do the following as the system administrator user:



Step 1   Create User


The following SQL statement creates a user called MYUSER with a password of myuser_password:


CREATE USER myuser IDENTIFIED BY myuser_password;

Step 2   Grant Roles


The following SQL statement grants the required roles of RESOURCE, CONNECT, and CTXAPP to MYUSER:


GRANT RESOURCE, CONNECT, CTXAPP TO MYUSER;

Step 3   Grant EXECUTE Privileges on CTX PL/SQL Packages


Oracle Text includes several packages that let you perform actions ranging from synchronizing an Oracle Text index to highlighting documents. For example, the CTX_DDL package includes the SYNC_INDEX procedure, which enables you to synchronize your index. The Oracle Text Reference describes each of these packages in its own chapter.


To call any of these procedures from a stored procedure, your application requires execute privileges on the packages. For example, to grant to MYUSER execute privileges on all Oracle Text packages, enter the following SQL statements:


GRANT EXECUTE ON CTXSYS.CTX_CLS TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_DDL TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_DOC TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_OUTPUT TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_QUERY TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_REPORT TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_THES TO myuser;
GRANT EXECUTE ON CTXSYS.CTX_ULEXER TO myuser;









2.3 Query Application Quick Tour


In a basic text query application, users enter query words or phrases and expect the application to return a list of documents that best match the query. Such an application involves creating a CONTEXT index and querying it with CONTAINS.


This example steps you through the basic SQL statements to load the text table, index the documents, and query the index.


Typically, query applications require a user interface. An example of how to build such a query application using the CONTEXT index type is given in Appendix A.



Step 1   Connect as the New User


Before creating any tables, assume the identity of the user you just created.


CONNECT myuser;

Step 2   Create your Text Table


The following example creates a table called docs with two columns, id and text, by using the CREATE TABLE statement. This example makes the id column the primary key. The text column is VARCHAR2.


CREATE TABLE docs (id NUMBER PRIMARY KEY, text VARCHAR2(200));

Step 3   Load Documents into Table


Use the SQL INSERT statement to load text to a table.


To populate the docs table, use the INSERT statement as follows:


INSERT INTO docs VALUES(1, '<HTML>California is a state in the US.</HTML>');
INSERT INTO docs VALUES(2, '<HTML>Paris is a city in France.</HTML>');
INSERT INTO docs VALUES(3, '<HTML>France is in Europe.</HTML>');




Using SQL*Loader


You can also load your table in batch with SQL*Loader.









See Also:

"Building the Web Application" for an example on how to use SQL*Loader to load a text table from a data file






Step 1   Create the CONTEXT index


Index the HTML files by creating a CONTEXT index on the text column as follows. Because you are indexing HTML, this example uses the NULL_FILTER preference type for no filtering and the HTML_SECTION_GROUP type:


CREATE INDEX idx_docs ON docs(text)
     INDEXTYPE IS CTXSYS.CONTEXT PARAMETERS
     ('FILTER CTXSYS.NULL_FILTER SECTION GROUP CTXSYS.HTML_SECTION_GROUP');



Use the NULL_FILTER, because you do not need to filter HTML documents during indexing. However, if you index PDF, Microsoft Word, or other formatted documents, then use the CTXSYS.AUTO_FILTER (the default) as your FILTER preference.


This example also uses the HTML_SECTION_GROUP section group, which is recommended for indexing HTML documents. Using HTML_SECTION_GROUP enables you to search within specific HTML tags and eliminates from the index unwanted markup such as font information.


Step 2   Querying Your Table with CONTAINS


First, set the format of the SELECT statement's output so it is easily readable. Set the width of the text column to 40 characters:


COLUMN text FORMAT a40;



Now query the table with the SELECT statement with CONTAINS. This retrieves the document IDs that satisfy the query. The following query looks for all documents that contain the word France:


SELECT SCORE(1), id, text FROM docs WHERE CONTAINS(text, 'France', 1) > 0;

  SCORE(1)         ID TEXT
---------- ---------- ----------------------------------------
         4          3 <HTML>France is in Europe.</HTML>
         4          2 <HTML>Paris is a city in France.</HTML>

Step 3   Present the Document


In a real application, you might want to present the selected document to the user with query terms highlighted. Oracle Text enables you to mark up documents with the CTX_DOC package.


We can demonstrate HTML document markup with an anonymous PL/SQL block in SQL*Plus. However, in a real application you might present the document in a browser.


This PL/SQL example uses the in-memory version of CTX_DOC.MARKUP to highlight the word France in document 3. It allocates a temporary CLOB (Character Large Object datatype) to store the markup text and reads it back to the standard output. The CLOB is then de-allocated before exiting:


SET SERVEROUTPUT ON;
DECLARE
  2  mklob CLOB;
  3  amt NUMBER := 40;
  4  line VARCHAR2(80);
  5  BEGIN
  6    CTX_DOC.MARKUP('idx_docs','3','France', mklob);
  7    DBMS_LOB.READ(mklob, amt, 1, line);
  8    DBMS_OUTPUT.PUT_LINE('FIRST 40 CHARS ARE:'||line);
  9    DBMS_LOB.FREETEMPORARY(mklob);
 10    END;
 11  /
FIRST 40 CHARS ARE:<HTML><<<France>>> is in Europe.</HTML>

PL/SQL procedure successfully completed.

Step 4   Synchronize the Index After Data Manipulation


When you create a CONTEXT index, you need to explicitly synchronize your index to keep it up to date with any inserts, updates, or deletes to the text table.


Oracle Text enables you to do so with the CTX_DDL.SYNC_INDEX procedure.


Add some rows to the docs table:


INSERT INTO docs VALUES(4, '<HTML>Los Angeles is a city in California.</HTML>');
INSERT INTO docs VALUES(5, '<HTML>Mexico City is big.</HTML>');



Because the index is not synchronized, these new rows are not returned with a query on city:


SELECT SCORE(1), id, text FROM docs WHERE CONTAINS(text, 'city', 1) > 0;

  SCORE(1)         ID TEXT
---------- ---------- --------------------------------------------------
         4          2 <HTML>Paris is a city in France.</HTML>



Therefore, synchronize the index with 2Mb of memory, and rerun the query:


EXEC CTX_DDL.SYNC_INDEX('idx_docs', '2M');

PL/SQL procedure successfully completed.

COLUMN text FORMAT a50;
SELECT SCORE(1), id, text FROM docs WHERE CONTAINS(text, 'city', 1) > 0;

  SCORE(1)         ID TEXT
---------- ---------- --------------------------------------------------
         4          5 <HTML>Mexico City is big.</HTML>
         4          4 <HTML>Los Angeles is a city in California.</HTML>
         4          2 <HTML>Paris is a city in France.</HTML>






2.3.1 Building Web Applications with the Oracle Text Wizard


Oracle Text enables you to build simple text and catalog Web applications with the Oracle Text Wizard add-on for Oracle JDeveloper. The wizard automatically generates Java Server Pages or PL/SQL server scripts you can use with the Oracle-configured Apache Web server.


Both JDeveloper and the Text Wizard can be downloaded for free from the Oracle Technology Network.





2.3.1.1 Oracle JDeveloper


Obtain the latest JDeveloper software from the following URL:


http://www.oracle.com/technology/software/products/jdev


See "Building the JSP Web Application" for an example.








2.3.1.2 Oracle Text Wizard Addins


Obtain the Text, Catalog, and Classification Wizard addins from the following URL:


http://www.oracle.com/technology/software/products/text








2.3.1.3 Oracle Text Wizard Instructions


Find instructions on using the Oracle Text Wizard and setting up your JSP files to run in a Web server environment from the following URL:


http://www.oracle.com/technology/software/products/text


Follow the "Text Search Wizard for JDeveloper" link.












2.4 Catalog Application Quick Tour


This example creates a catalog index for an auction site that sells electronic equipment, such as cameras and CD players. New inventory is added everyday and item descriptions, bid dates, and prices must be stored together.


The application requires good response time for mixed queries. The key is to determine what columns users frequently search to create a suitable CTXCAT index. Queries on this type of index are entered with the CATSEARCH operator.









Note:

Typically, query applications require a user interface. An example of how to build such a query application using the CATSEARCH index type is given in Appendix B.






Step 1   Connect as the Appropriate User


Connect as the CTXAPP role the user myuser:


CONNECT myuser;

Step 2   Create Your Table


Set up an auction table to store your inventory:


CREATE TABLE auction(
item_id NUMBER,
title VARCHAR2(100),
category_id NUMBER,
price NUMBER,
bid_close DATE);



Figure 2-1 illustrates this table.


Step 3   Populate Your Table


Populate the table with various items, each with an id, title, price and bid_date:


INSERT INTO AUCTION VALUES(1, 'NIKON CAMERA', 1, 400, '24-OCT-2002');
INSERT INTO AUCTION VALUES(2, 'OLYMPUS CAMERA', 1, 300, '25-OCT-2002');
INSERT INTO AUCTION VALUES(3, 'PENTAX CAMERA', 1, 200, '26-OCT-2002');
INSERT INTO AUCTION VALUES(4, 'CANON CAMERA', 1, 250, '27-OCT-2002'); 




Using SQL*Loader


You can also load your table in batch with SQL*Loader.









See Also:

"Building the Web Application" for an example on how to use SQL*Loader to load a text table from a data file






Step 1   Determine your Queries


Determine what criteria are likely to be retrieved. In this example, you determine that all queries search the title column for item descriptions, and most queries order by price. When using the CATSEARCH operator later, we'll specify the terms for the text column and the criteria for the structured clause.


Step 2   Create the Sub-Index to Order by Price


For Oracle Text to serve these queries efficiently, we need a sub-index for the price column, because our queries will order by price.


Therefore, create an index set called auction_set and add a sub-index for the price column:


EXEC CTX_DDL.CREATE.INDEXT_SET('auction_iset');
EXEC CTX_DDL.ADD_INDEX('auction_iset','price'); /* sub-index A*/



Figure 2-1 shows how the sub-index relates to the columns.


Step 3   Create the CTXCAT Index


Create the combined catalog index on the AUCTION table with CREATE INDEX as follows:


CREATE INDEX auction_titlex ON AUCTION(title) INDEXTYPE IS CTXSYS.CTXCAT PARAMETERS ('index set auction_iset');



Figure 2-1 shows how the CTXCAT index and its sub-index relates to the columns.






Figure 2-1 Auction table schema and CTXCAT index

Description of Figure 2-1 follows

Description of "Figure 2-1 Auction table schema and CTXCAT index"





Step 1   Querying Your Table with CATSEARCH


When you have created the CTXCAT index on the AUCTION table, you can query this index with the CATSEARCH operator.


First set the output format to make the output readable:


COLUMN title FORMAT a40;



Now run the query:


SELECT title, price FROM auction WHERE CATSEARCH(title, 'CAMERA', 'order by price')> 0;

TITLE                PRICE
--------------- ----------
PENTAX CAMERA          200
CANON CAMERA           250
OLYMPUS CAMERA         300
NIKON CAMERA           400

SELECT title, price FROM auction WHERE CATSEARCH(title, 'CAMERA', 
     'price <= 300')>0;

TITLE                PRICE
--------------- ----------
PENTAX CAMERA          200
CANON CAMERA           250
OLYMPUS CAMERA         300

Step 2   Update Your Table


Update your catalog table by adding new rows. When you do so, the CTXCAT index is automatically synchronized to reflect the change.


For example, add the following new rows to our table and then rerun the query:


INSERT INTO AUCTION VALUES(5, 'FUJI CAMERA', 1, 350, '28-OCT-2002');
INSERT INTO AUCTION VALUES(6, 'SONY CAMERA', 1, 310, '28-OCT-2002');

SELECT title, price FROM auction WHERE CATSEARCH(title, 'CAMERA', 'order by price')> 0;

TITLE                                    PRICE
----------------------------------- ----------
PENTAX CAMERA                              200
CANON CAMERA                               250
OLYMPUS CAMERA                             300
SONY CAMERA                                310
FUJI CAMERA                                350
NIKON CAMERA                               400

6 rows selected.



Note how the added rows show up immediately in the query.










2.5 Classification Application Quick Tour


The function of a classification application is to perform some action based on document content. These actions can include assigning a category ID to a document or sending the document to a user. The result is classification of a document.


Documents are classified according to predefined rules. These rules select for a category. For instance, a query rule of 'presidential elections' might select documents for a category about politics.


Oracle Text provides several types of classification. One type is simple, or rule-based classification, discussed here, in which you create both document categories and the rules for categorizing documents. With supervised classification, Oracle Text derives the rules from a set of training documents you provide. With clustering, Oracle Text does all the work for you, deriving both rules and categories. (For more on classification, see "Overview of Document Classification".)


To create simple classification for document content using Oracle Text, create rules. Rules are essentially a table of queries that categorize document content. Index these rules in a CTXRULE index. To classify an incoming stream of text, use the MATCHES operator in the WHERE clause of a SELECT statement. See Figure 2-2 for the general flow of a classification application.




Figure 2-2 Overview of a Document Classification Application

Description of Figure 2-2 follows

Description of "Figure 2-2 Overview of a Document Classification Application"








2.5.1 Steps for Creating a Classification Application


The following example shows how to classify documents by defining simple categories, creating a CTXRULE index, and using MATCHES, using the CTXAPP role user myuser.


Step 1   Connect As the Appropriate User


Connect as the CTXAPP role user myuser:


CONNECT myuser;

Step 2   Create the Rule Table


We must create a rule table and populate it with query rules. In this example, we create a table called queries. Each row defines a category with an ID, and a rule which is a query string:


CREATE TABLE queries (
      query_id      NUMBER,
      query_string  VARCHAR2(80)
    );

    INSERT INTO queries VALUES (1, 'oracle');
    INSERT INTO queries VALUES (2, 'larry or ellison');
    INSERT INTO queries VALUES (3, 'oracle and text');
    INSERT INTO queries VALUES (4, 'market share');

Step 3   Create Your CTXRULE Index


Create a CTXRULE index as follows:


CREATE INDEX queryx ON queries(query_string) INDEXTYPE IS CTXRULE;

Step 4   Classify with MATCHES


Use the MATCHES operator in the WHERE clause of a SELECT statement to match documents to queries and hence classify.


    COLUMN query_string FORMAT a35;
    SELECT query_id,query_string FROM queries
     WHERE MATCHES(query_string, 
                   'Oracle announced that its market share in databases 
                    increased over the last year.')>0;

  QUERY_ID QUERY_STRING                                                         
---------- -----------------------------------                                  
         1 oracle                                                               
         4 market share                                                         



As shown, the document string matches categories 1 and 4. With this classification you can perform an action, such as writing the document to a specific table or e-mailing a user.







See Also:

Chapter 6, "Classifying Documents in Oracle Text" for more extended classification examples














PK.8m3mPK&AOEBPS/csection.htm

Searching Document Sections in Oracle Text



8 Searching Document Sections in Oracle Text


This chapter describes how to use document sections in an Oracle Text query application.


The following topics are discussed in this chapter:






8.1 About Oracle Text Document Section Searching


Section searching enables you to narrow text queries down to blocks of text within documents. Section searching is useful when your documents have internal structure, such as HTML and XML documents.


You can also search for text at the sentence and paragraph level.


This section contains these topics:






8.1.1 Enabling Oracle Text Section Searching


The steps for enabling section searching for your document collection are:


  1. 

    Create a section group
    

  2. 

    Define your sections
    

  3. 

    Index your documents
    

  4. 

    Section search with WITHIN, INPATH, or HASPATH operators
    






8.1.1.1 Create a Section Group


Section searching is enabled by defining section groups. You use one of the system-defined section groups to create an instance of a section group. Choose a section group appropriate for your document collection.


You use section groups to specify the type of document set you have and implicitly indicate the tag structure. For instance, to index HTML tagged documents, you use the HTML_SECTION_GROUP. Likewise, to index XML tagged documents, you can use the XML_SECTION_GROUP.


Table 8-1 lists the different types of section groups you can use:




Table 8-1 Types of Section Groups


Section Group PreferenceDescription


NULL_SECTION_GROUP



This is the default. Use this group type when you define no sections or when you define only SENTENCE or PARAGRAPH sections.




BASIC_SECTION_GROUP



Use this group type for defining sections where the start and end tags are of the form <A> and </A>.


Note: This group type dopes not support input such as unbalanced parentheses, comments tags, and attributes. Use HTML_SECTION_GROUP for this type of input.




HTML_SECTION_GROUP



Use this group type for indexing HTML documents and for defining sections in HTML documents.




XML_SECTION_GROUP



Use this group type for indexing XML documents and for defining sections in XML documents.




AUTO_SECTION_GROUP



Use this group type to automatically create a zone section for each start-tag/end-tag pair in an XML document. The section names derived from XML tags are case-sensitive as in XML.


Attribute sections are created automatically for XML tags that have attributes. Attribute sections are named in the form tag@attribute.


Stop sections, empty tags, processing instructions, and comments are not indexed.


The following limitations apply to automatic section groups:


  • 

    You cannot add zone, field or special sections to an automatic section group.
    

  • 

    Automatic sectioning does not index XML document types (root elements.) However, you can define stop-sections with document type.
    

  • 

    The length of the indexed tags including prefix and namespace cannot exceed 64 bytes. Tags longer than this are not indexed.
    





PATH_SECTION_GROUP



Use this group type to index XML documents. Behaves like the AUTO_SECTION_GROUP.


The difference is that with this section group you can do path searching with the INPATH and HASPATH operators. Queries are also case-sensitive for tag and attribute names.




NEWS_SECTION_GROUP



Use this group for defining sections in newsgroup formatted documents according to RFC 1036.












Note:

Documents sent to the HTML, XML, AUTO and PATH sectioners must begin with \s*<, where \s* represents zero or more whitespace characters. Otherwise, the document is treated as a plaintext document, and no sections are recognized.





You use the CTX_DDL package to create section groups and define sections as part of section groups. For example, to index HTML documents, create a section group with HTML_SECTION_GROUP:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
end;







8.1.1.2 Define Your Sections


You define sections as part of the section group. The following example defines an zone section called heading for all text within the HTML < H1> tag:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_zone_section('htmgroup', 'heading', 'H1');
end;










Note:

If you are using the AUTO_SECTION_GROUP or PATH_SECTION_GROUP to index an XML document collection, then you need not explicitly define sections. The system does this for you during indexing.













See Also:















8.1.1.3 Index Your Documents


When you index your documents, you specify your section group in the parameter clause of CREATE INDEX.


create index myindex on docs(htmlfile) indextype is ctxsys.context 
parameters('filter ctxsys.null_filter section group htmgroup');







8.1.1.4 Section Searching with the WITHIN Operator


When your documents are indexed, you can query within sections using the WITHIN operator. For example, to find all the documents that contain the word Oracle within their headings, enter the following query:


'Oracle WITHIN heading'










See Also:

Oracle Text Reference to learn more about using the WITHIN operator












8.1.1.5 Path Searching with INPATH and HASPATH Operators


When you use the PATH_SECTION_GROUP, the system automatically creates XML sections for you. In addition to using the WITHIN operator to enter queries, you can enter path queries with the INPATH and HASPATH operators.









See Also:

















8.1.2 Oracle Text Section Types


All section types are blocks of text in a document. However, sections can differ in the way that they are delimited and the way that they are recorded in the index. Sections can be one of the following types:



Table 8-2 shows which section types may be used with each kind of section group.




Table 8-2 Section Types and Section Groups


Section GroupZONEFIELDSTOPMDATASDATAATTRIBUTESPECIAL


NULL



NO



NO



NO



NO



NO



NO



YES




BASIC



YES



YES



NO



YES



YES



NO



YES




HTML



YES



YES



NO



YES



YES



NO



YES




XML



YES



YES



NO



YES



YES



YES



YES




NEWS



YES



YES



NO



YES



YES



NO



YES




AUTO



NO



NO



YES



NO



NO



NO



NO




PATH



NO



NO



NO



NO



NO



NO



NO










8.1.2.1 Zone Section


A zone section is a body of text delimited by start and end tags in a document. The positions of the start and end tags are recorded in the index so that any words in between the tags are considered to be within the section. Any instance of a zone section must have a start and an end tag.


For example, the text between the <TITLE> and </TITLE> tags can be defined as a zone section as follows:


<TITLE>Tale of Two Cities</TITLE>
It was the best of times...



Zone sections can nest, overlap, and repeat within a document.


When querying zone sections, you use the WITHIN operator to search for a term across all sections. Oracle Text returns those documents that contain the term within the defined section.


Zone sections are well suited for defining sections in HTML and XML documents. To define a zone section, use CTX_DDL.ADD_ZONE_SECTION.


For example, assume you define the section booktitle as follows:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_zone_section('htmgroup', 'booktitle', 'TITLE');
end;



After you index, you can search for all the documents that contain the term Cities within the section booktitle as follows:


'Cities WITHIN booktitle'



With multiple query terms such as (dog and cat) WITHIN booktitle, Oracle Text returns those documents that contain cat and dog within the same instance of a booktitle section.





8.1.2.1.1 Repeated Zone Sections


Zone sections can repeat. Each occurrence is treated as a separate section. For example, if <H1> denotes a heading section, they can repeat in the same documents as follows:


<H1> The Brown Fox </H1>
<H1> The Gray Wolf </H1>



Assuming that these zone sections are named Heading, the query Brown WITHIN Heading returns this document. However, a query of (Brown and Gray) WITHIN Heading does not.








8.1.2.1.2 Overlapping Zone Sections


Zone sections can overlap each other. For example, if <B> and <I> denote two different zone sections, they can overlap in a document as follows:


plain <B> bold <I> bold and italic </B> only italic </I>  plain







8.1.2.1.3 Nested Zone Sections


Zone sections can nest, including themselves as follows:


<TD> <TABLE><TD>nested cell</TD></TABLE></TD>



Using the WITHIN operator, you can write queries to search for text in sections within sections. For example, assume the BOOK1, BOOK2, and AUTHOR zone sections occur as follows in documents doc1 and doc2:


doc1:


<book1> <author>Scott Tiger</author> This is a cool book to read.</book1>



doc2:


<book2> <author>Scott Tiger</author> This is a great book to read.</book2>



Consider the nested query:


'(Scott within author) within book1'



This query returns only doc1.










8.1.2.2 Field Section


A field section is similar to a zone section in that it is a region of text delimited by start and end tags. A field section is different from a zone section in that the region is indexed separately from the rest of the document.


Since field sections are indexed differently, you can also get better query performance over zone sections for when you have a large number of documents indexed.


Field sections are more suited to when you have a single occurrence of a section in a a document such as a field in a news header. Field sections can also be made visible to the rest of the document.


Unlike zone sections, field sections have the following restrictions:


  • 

    Field sections cannot overlap
    

  • 

    Field sections cannot repeat
    

  • 

    Field sections cannot nest
    






8.1.2.2.1 Visible and Invisible Field Sections


By default, field sections are indexed as a sub-document separate from the rest of the document. As such, field sections are invisible to the surrounding text and can only be queried by explicitly naming the section in the WITHIN clause.


You can make field sections visible if you want the text within the field section to be indexed as part of the enclosing document. Text within a visible field section can be queried with or without the WITHIN operator.


The following example shows the difference between using invisible and visible field sections.


The following code defines a section group basicgroup of the BASIC_SECTION_GROUP type. It then creates a field section in basicgroup called Author for the <A> tag. It also sets the visible flag to FALSE to create an invisible section:


begin
ctx_ddl.create_section_group('basicgroup', 'BASIC_SECTION_GROUP');
ctx_ddl.add_field_section('basicgroup', 'Author', 'A', FALSE);
end;



Because the Author field section is not visible, to find text within the Author section, you must use the WITHIN operator as follows:


'(Martin Luther King) WITHIN Author'



A query of Martin Luther King without the WITHIN operator does not return instances of this term in field sections. If you want to query text within field sections without specifying WITHIN, you must set the visible flag to TRUE when you create the section as follows:


begin
ctx_ddl.add_field_section('basicgroup', 'Author', 'A', TRUE);
end;







8.1.2.2.2 Nested Field Sections


Field sections cannot be nested. For example, if you define a field section to start with <TITLE> and define another field section to start with <FOO>, the two sections cannot be nested as follows:


<TITLE> dog <FOO> cat </FOO> </TITLE>



To work with nested sections, define them as zone sections.








8.1.2.2.3 Repeated Field Sections


Repeated field sections are allowed, but WITHIN queries treat them as a single section. The following is an example of repeated field section in a document:


<TITLE> cat </TITLE>
<TITLE> dog </TITLE>



The query dog and cat within title returns the document, even though these words occur in different sections.


To have WITHIN queries distinguish repeated sections, define them as zone sections.










8.1.2.3 Stop Section


A stop section may be added to an automatic section group. Adding a stop section causes the automatic section indexing operation to ignore the specified section in XML documents.









Note:

Adding a stop section causes no section information to be created in the index. However, the text within a stop section is always searchable.






Adding a stop section is useful when your documents contain many low-information tags. Adding stop sections also improves indexing performance with the automatic section group.


The number of stop sections you can add is unlimited.


Stop sections do not have section names and hence are not recorded in the section views.








8.1.2.4 MDATA Section


An MDATA section is used to reference user-defined metadata for a document. Using MDATA sections can speed up mixed queries.


Consider the case in which you want to query both according to text content and document type (magazine or newspaper or novel). You could create an index with a column for text and a column for the document type, and then perform a mixed query of this form—in this case, searching for all novels with the phrase Adam Thorpe (author of the novel Ulverton):


SELECT id FROM documents
   WHERE doctype = 'novel'
      AND CONTAINS(text, 'Adam Thorpe')>0;



However, it is usually faster to incorporate the attribute (in this case, the document type) into a field section, rather than use a separate column, and then use a single CONTAINS query:


SELECT id FROM documents
  WHERE CONTAINS(text, 'Adam Thorpe AND novel WITHIN doctype')>0;



There are two drawbacks to this approach:


  • 

    Each time the attribute is updated, the entire text document must be re-indexed, resulting in increased index fragmentation and slower rates of processing DML.
    

  • 

    Field sections tokenize the section value. This has several effects. Special characters in metadata, such as decimal points or currency characters, are not easily searchable; value searching (searching for Thurston Howell but not Thurston Howell, Jr.) is difficult; multi-word values are queried by phrase, which is slower than single-token searching; and multi-word values do not show up in browse-words, making author browsing or subject browsing impossible.
    



For these reasons, using MDATA sections instead of field sections may be worthwhile. MDATA sections are indexed like field sections, but metadata values can be added to and removed from documents without the need to re-index the document text. Unlike field sections, MDATA values are not tokenized. Additionally, MDATA section indexing generally takes up less disk space than field section indexing.


Use CTX_DDL.ADD_MDATA_SECTION to add an MDATA section to a section group. This example adds an MDATA section called AUTHOR and gives it the value Soseki Natsume (author of the novel Kokoro).


ctx_ddl.create.section.group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_mdata_section('htmgroup', 'author', 'Soseki Natsume');



MDATA values can be changed with CTX_DDL.ADD_MDATA and removed with CTX_DDL.REMOVE_MDATA. Also, MDATA sections can have multiple values. Only the owner of the index is allowed to call CTX_DDL.ADD_MDATA and CTX_DDL.REMOVE_MDATA.


Neither CTX_DDL.ADD_MDATA nor CTX_DDL.REMOVE_MDATA are supported for CTXCAT, CTXXPTH and CTXRULE indexes.


MDATA values are not passed through a lexer. Instead, all values undergo a simplified normalization:


  • 

    Leading and trailing whitespace on the value is removed.
    

  • 

    The value is truncated to 64 bytes.
    

  • 

    The value is indexed as a single value; if the value consists of multiple words, it is not broken up.
    

  • 

    Case is preserved. If the document is dynamically generated, you can implement case-insensitivity by uppercasing MDATA values and making sure to search only in uppercase.
    



After a document has had MDATA metadata added to it, you can query for that metadata using the MDATA CONTAINS query operator:


SELECT id FROM documents
   WHERE CONTAINS(text, 'Tokyo and MDATA(author, Soseki Natsume)')>0;



This query will only be successful if an AUTHOR tag has the exact value Soseki Natsume (after simplified tokenization). Soseki or Natsume Soseki will not work.


Other things to note about MDATA:


  • 

    MDATA values are not highlightable, will not appear in the output of CTX_DOC.TOKENS, and will not show up when FILTER PLAINTEXT is enabled.
    

  • 

    MDATA sections must be unique within section groups. You cannot have an MDATA section named FOO and a zone or field section of the same name in the same section group.
    

  • 

    Like field sections, MDATA sections cannot overlap or nest. An MDATA section is implicitly closed by the first tag encountered. For instance, in this example:
    

    <AUTHOR>Dickens <B>Shelley</B> Keats</AUTHOR>

    

    The <B> tag closes the AUTHOR MDATA section; as a result, this document has an AUTHOR of 'Dickens', but not of 'Shelley' or 'Keats'.
    

  • 

    To prevent race conditions, each call to ADD_MDATA and REMOVE_MDATA locks out other calls on that rowid for that index for all values and sections. However, since ADD_MDATA and REMOVE_MDATA do not commit, it is possible for an application to deadlock when calling them both. It is the application's responsibility to prevent deadlocking.
    








See Also:


  • 

    The CONTAINS query operators chapter of the Oracle Text Reference for information on the MDATA operator
    

  • 

    The CTX_DDL package chapter of Oracle Text Reference for information on adding and removing MDATA sections
    












8.1.2.5 NDATA Section


Fields containing data to be indexed for name searching can be specified exclusively by adding NDATA sections to section groups of type: BASIC_SECTION_GROUP, HTML_SECTION_GROUP, or XML_SECTION_GROUP.


Users can synthesize textual documents, which contain name data, using two possible datastores: MULTI_COLUMN_DATASTORE or USER_DATASTORE. The following is an example of using MULTI_COLUMN_DATASTORE to pick up relevant columns containing the name data for indexing:


create table people(firstname varchar2(80), surname varchar2(80));
 insert into people values('John', 'Smith');
 commit;
 begin
   ctx_ddl.create_preference('nameds', 'MULTI_COLUMN_DATASTORE');
   ctx_ddl.set_attribute('nameds', 'columns', 'firstname,surname');
 end;
 / 



This produces the following virtual text for indexing:


<FIRSTNAME>
John
</FIRSTNAME>
<SURNAME>
Smith
</SURNAME>



You can then create NDATA sections for FIRSTNAME and SURNAME sections:


begin
  ctx_ddl.create_section_group('namegroup', 'BASIC_SECTION_GROUP');
  ctx_ddl.add_ndata_section('namegroup', 'FIRSTNAME', 'FIRSTNAME');
  ctx_ddl.add_ndata_section('namegroup', 'SURNAME', 'SURNAME');
end;
/



Then create the index using the datastore preference and section group preference created earlier:


create index peopleidx on people(firstname) indextype is ctxsys.context
parameters('section group namegroup datastore nameds');



NDATA sections support both single- and multi-byte data, however, there are character- and term-based limitations. NDATA section data that is indexed is constrained as follows:


  • 

    the number of characters in a single, white space delimited term
    

    511
    

  • 

    the number of white space delimited terms
    

    255
    

  • 

    the total number of characters, including white spaces
    

    511
    









8.1.2.6 SDATA Section


The value of an SDATA section is extracted from the document text like other sections, but is indexed as structured data, also referred to as SDATA. Using SDATA sections supports operations such as projection, range searches, and ordering. It also enables SDATA indexing of section data such as embedded tags, and detail table or function invocations. This enables you to perform various combinations of text and structured searches in one single SQL statement.


SDATA operators should be used only as descendants of AND operators that also have non-SDATA children. SDATA operators are meant to be used as secondary, checking or non-driving, criteria. For instance, "find documents with DOG that also have price > 5", rather than "find documents with rating > 4". Other uses will operate properly, but may not have optimal performance.


You use CTX_DDL.ADD_SDATA_SECTION to add an SDATA section to a section group. When querying within an SDATA section, you use the CONTAINS operator. The following example creates a table called items, and adds an SDATA section called my_sec_group, and then queries SDATA in the section.


Create the table items:


CREATE TABLE items 
(id  NUMBER PRIMARY KEY, 
 doc VARCHAR2(4000));
 
INSERT INTO items VALUES (1, '<description> Honda Pilot </description>
                              <category> Cars & Trucks </category>
                              <price> 27000 </price>');
INSERT INTO items VALUES (2, '<description> Toyota Sequoia </description>
                              <category> Cars & Trucks </category>
                              <price> 35000 </price>');
INSERT INTO items VALUES (3, '<description> Toyota Land Cruiser </description>
                              <category> Cars & Trucks </category>
                              <price> 45000 </price>');
INSERT INTO items VALUES (4, '<description> Palm Pilot </description>
                              <category> Electronics </category>
                              <price> 5 </price>');
INSERT INTO items VALUES (5, '<description> Toyota Land Cruiser Grill </description>
                              <category> Parts & Accessories </category>
                              <price> 100 </price>');
COMMIT;



Add SDATA section my_sec_group:


BEGIN
  CTX_DDL.CREATE_SECTION_GROUP('my_sec_group', 'BASIC_SECTION_GROUP');
  CTX_DDL.ADD_SDATA_SECTION('my_sec_group', 'category', 'category', 'VARCHAR2');
  CTX_DDL.ADD_SDATA_SECTION('my_sec_group', 'price', 'price', 'NUMBER');
END;
 



Create the CONTEXT index:


CREATE INDEX items$doc 
  ON items(doc) 
  INDEXTYPE IS CTXSYS.CONTEXT
  PARAMETERS('SECTION GROUP my_sec_group');
 



Run a query:


SELECT id, doc
  FROM items
  WHERE contains(doc, 'Toyota 
                       AND SDATA(category = ''Cars & Trucks'') 
                       AND SDATA(price <= 40000 )') > 0;



Return the results:


  ID DOC
---- ----------------------------------------------------------------------
   2 <description> Toyota Sequoia </description>
                                   <category> Cars & Trucks </category>
                                   <price> 35000 </price>








See Also:













8.1.2.7 Attribute Section


You can define attribute sections to query on XML attribute text. You can also have the system automatically define and index XML attributes for you.









8.1.2.8 Special Sections


Special sections are not recognized by tags. Currently the only special sections supported are sentence and paragraph. This enables you to search for combination of words within sentences or paragraphs.


The sentence and paragraph boundaries are determined by the lexer. For example, the BASIC_LEXER recognizes sentence and paragraph section boundaries as follows:




Table 8-3 Sentence and Paragraph Section Boundaries for BASIC_LEXER


Special SectionBoundary


SENTENCE



WORD/PUNCT/WHITESPACE





WORD/PUNCT/NEWLINE




PARAGRAPH



WORD/PUNCT/NEWLINE/WHITESPACE





WORD/PUNCT/NEWLINE/NEWLINE







If the lexer cannot recognize the boundaries, no sentence or paragraph sections are indexed.


To add a special section, use the CTX_DDL.ADD_SPECIAL_SECTION procedure. For example, the following code enables searching within sentences within HTML documents:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_special_section('htmgroup', 'SENTENCE');
end;



You can also add zone sections to the group to enable zone searching in addition to sentence searching. The following example adds the zone section Headline to the section group htmgroup:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_special_section('htmgroup', 'SENTENCE');
ctx_ddl.add_zone_section('htmgroup', 'Headline', 'H1');
end;











8.2 HTML Section Searching with Oracle Text


HTML has internal structure in the form of tagged text which you can use for section searching. For example, you can define a section called headings for the <H1> tag. This enables you to search for terms only within these tags across your document set.


To query, you use the WITHIN operator. Oracle Text returns all documents that contain your query term within the headings section. Thus, if you wanted to find all documents that contain the word oracle within headings, enter the following query:


'oracle within headings'



This section contains these topics:






8.2.1 Creating HTML Sections


The following code defines a section group called htmgroup of type HTML_SECTION_GROUP. It then creates a zone section in htmgroup called heading identified by the <H1> tag:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_zone_section('htmgroup', 'heading', 'H1');
end;



You can then index your documents as follows:


create index myindex on docs(htmlfile) indextype is ctxsys.context
parameters('filter ctxsys.null_filter section group htmgroup');



After indexing with section group htmgroup, you can query within the heading section by issuing a query as follows:


'Oracle WITHIN heading'







8.2.2 Searching HTML Meta Tags


With HTML documents you can also create sections for NAME/CONTENT pairs in <META> tags. When you do so you can limit your searches to text within CONTENT.





8.2.2.1 Example: Creating Sections for <META>Tags 


Consider an HTML document that has a META tag as follows:


<META NAME="author" CONTENT="ken">



To create a zone section that indexes all CONTENT attributes for the META tag whose NAME value is author:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_zone_section('htmgroup', 'author', 'meta@author');
end



After indexing with section group htmgroup, you can query the document as follows:


'ken WITHIN author'











8.3 XML Section Searching with Oracle Text


Like HTML documents, XML documents have tagged text which you can use to define blocks of text for section searching. The contents of a section can be searched on with the WITHIN or INPATH operators.


The following sections describe the different types of XML searching:






8.3.1 Automatic Sectioning


You can set up your indexing operation to automatically create sections from XML documents using the section group AUTO_SECTION_GROUP. The system creates zone sections for XML tags. Attribute sections are created for the tags that have attributes and these sections named in the form tag@attribute.


For example, the following statement creates the index myindex on a column containing the XML files using the AUTO_SECTION_GROUP:


CREATE INDEX myindex
ON xmldocs(xmlfile)
 INDEXTYPE IS ctxsys.context
PARAMETERS ('datastore ctxsys.default_datastore 
             filter ctxsys.null_filter 
             section group ctxsys.auto_section_group'
           );







8.3.2 Attribute Searching


You can search XML attribute text in one of two ways:


  • 

    Create attribute sections with CTX_DDL.ADD_ATTR_SECTION and then index with XML_SECTION_GROUP. If you use AUTO_SECTION_GROUP when you index, attribute sections are created automatically. You can query attribute sections with the WITHIN operator.
    

  • 

    Index with the PATH_SECTION_GROUP and query attribute text with the INPATH operator.
    






8.3.2.1 Creating Attribute Sections


Consider an XML file that defines the BOOK tag with a TITLE attribute as follows:


<BOOK TITLE="Tale of Two Cities"> 
  It was the best of times. 
</BOOK> 



To define the title attribute as an attribute section, create an XML_SECTION_GROUP and define the attribute section as follows:


begin
ctx_ddl.create_section_group('myxmlgroup', 'XML_SECTION_GROUP');
ctx_ddl.add_attr_section('myxmlgroup', 'booktitle', 'book@title');
end;



To index:


CREATE INDEX myindex
ON xmldocs(xmlfile)
INDEXTYPE IS ctxsys.context
PARAMETERS ('datastore ctxsys.default_datastore 
             filter ctxsys.null_filter 
             section group myxmlgroup'
           );



You can query the XML attribute section booktitle as follows:


'Cities within booktitle'







8.3.2.2 Searching Attributes with the INPATH Operator


You can search attribute text with the INPATH operator. To do so, you must index your XML document set with the PATH_SECTION_GROUP.











8.3.3 Creating Document Type Sensitive Sections


For an XML document set that contains the <book> tag declared for different document types, you may want to create a distinct book section for each document type. The following scenario shows how to create book sections for each document type to improve search capability.


Assume that mydocname1 is declared as an XML document type (root element) as follows:


<!DOCTYPE mydocname1 ... [...



Within mydocname1, the element <book> is declared. For this tag, you can create a section named mybooksec1 that is sensitive to the tag's document type as follows:


begin



ctx_ddl.create_section_group('myxmlgroup', 'XML_SECTION_GROUP');
ctx_ddl.add_zone_section('myxmlgroup', 'mybooksec1', 'mydocname1(book)');



end;



Assume that mydocname2 is declared as another XML document type (root element) as follows:


<!DOCTYPE mydocname2 ... [...



Within mydocname2, the element <book> is declared. For this tag, you can create a section named mybooksec2 that is sensitive to the tag's document type as follows:


begin



ctx_ddl.create_section_group('myxmlgroup', 'XML_SECTION_GROUP');
ctx_ddl.add_zone_section('myxmlgroup', 'mybooksec2', 'mydocname2(book)');



end;



To query within the section mybooksec1, use WITHIN as follows:


'oracle within mybooksec1'







8.3.4 Path Section Searching


XML documents can have parent-child tag structures such as:


<A> <B> <C> dog </C> </B> </A>



In this scenario, tag C is a child of tag B which is a child of tag A.


With Oracle Text, you can do path searching with PATH_SECTION_GROUP. This section group enables you to specify direct parentage in queries, such as to find all documents that contain the term dog in element C which is a child of element B and so on.


With PATH_SECTION_GROUP, you can also perform attribute value searching and attribute equality testing.


The new operators associated with this feature are


  • 

    INPATH
    

  • 

    HASPATH
    






8.3.4.1 Creating an Index with PATH_SECTION_GROUP


To enable path section searching, index your XML document set with PATH_SECTION_GROUP. For example:


Create the preference.


begin
ctx_ddl.create_section_group('xmlpathgroup', 'PATH_SECTION_GROUP');
end;



Create the index.


CREATE INDEX myindex
ON xmldocs(xmlfile)
INDEXTYPE IS ctxsys.context
PARAMETERS ('datastore ctxsys.default_datastore 
             filter ctxsys.null_filter 
             section group xmlpathgroup'
           );





When you create the index, you can use the INPATH and HASPATH operators.








8.3.4.2 Top-Level Tag Searching


To find all documents that contain the term dog in the top-level tag <A>:


dog INPATH (/A)



or


dog INPATH(A)







8.3.4.3 Any-Level Tag Searching


To find all documents that contain the term dog in the <A> tag at any level:


dog INPATH(//A)



This query finds the following documents:


<A>dog</A>



and


<C><B><A>dog</A></B></C>







8.3.4.4 Direct Parentage Searching


To find all documents that contain the term dog in a B element that is a direct child of a top-level A element:


dog INPATH(A/B)



This query finds the following XML document:


<A><B>My dog is friendly.</B></A>



but does not find:


<C><B>My dog is friendly.</B></C>







8.3.4.5 Tag Value Testing


You can test the value of tags. For example, the query:


dog INPATH(A[B="dog"])



Finds the following document:


<A><B>dog</B></A>



But does not find:


<A><B>My dog is friendly.</B></A>







8.3.4.6 Attribute Searching


You can search the content of attributes. For example, the query:


dog INPATH(//A/@B)



Finds the document


<C><A  B="snoop dog"> </A> </C>







8.3.4.7 Attribute Value Testing


You can test the value of attributes. For example, the query


California INPATH (//A[@B = "home address"])



Finds the document:


<A B="home address">San Francisco, California, USA</A>



But does not find:


<A B="work address">San Francisco, California, USA</A>







8.3.4.8 Path Testing


You can test if a path exists with the HASPATH operator. For example, the query:


HASPATH(A/B/C)



finds and returns a score of 100 for the document


<A><B><C>dog</C></B></A>



without the query having to reference dog at all.








8.3.4.9 Section Equality Testing with HASPATH


You can use the HASPATH operator to do section quality tests. For example, consider the following query:


dog INPATH A



finds


<A>dog</A>



but it also finds


<A>dog park</A>



To limit the query to the term dog and nothing else, you can use a section equality test with the HASPATH operator. For example,


HASPATH(A="dog")



finds and returns a score of 100 only for the first document, and not the second.









See Also:

Oracle Text Reference to learn more about using the INPATH and HASPATH operators
















PK
-	PK&A
OEBPS/toc.ncx3



      
      
      
      


   Oracle® Text Application Developer's Guide, 11g Release 2 (11.2)




   Cover

   



   Table of Contents

   



   List of Tables

   



   Oracle Text Application Developer's Guide, 11g Release 2 (11.2)

   



   Preface

   



   Understanding Oracle Text Application Development

   



   Getting Started with Oracle Text

   



   Indexing with Oracle Text

   



   Querying with Oracle Text

   



   Presenting Documents in Oracle Text

   



   Classifying Documents in Oracle Text

   



   Tuning Oracle Text

   



   Searching Document Sections in Oracle Text

   



   Using Oracle Text Name Search

   



   Working With a Thesaurus in Oracle Text

   



   Using XML Query Result Set Interface

   



   Administering Oracle Text

   



   Migrating Oracle Text Applications

   



   CONTEXT Query Application

   



   CATSEARCH Query Application

   



   Glossary

   



   Index

   



   Copyright

   



PK83PK&AOEBPS/content.opf-


      Oracle® Text Application Developer's Guide, 11g Release 2 (11.2)
      en-US
      
      E24435-01
      Oracle Corporation
      Oracle Corporation
      Oracle® Text Application Developer's Guide, 11g Release 2 (11.2)
      2011-07-27T18:47:41Z
      Provides information for building applications with Oracle Text.


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
    
    
    
    


   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   





PKs$--PK&AOEBPS/resultset.htm #

Using XML Query Result Set Interface



11 Using XML Query Result Set Interface


This chapter describes how to use the XML query result set interface, and includes:






11.1 Overview of the XML Query Result Set Interface


A page of search results in applications can consist of many disparate elements - metadata of the first few documents, total hit counts, per-word hit counts, and so on. Generating these results in earlier versions of Oracle Text required several queries and calls — perhaps a query on the base table, a call to CTX_QUERY.COUNT_HITS, and so on. Each extra call takes time to reparse the query and look up index metadata. Additionally, some search operations, such as iterative query refinement or breakdown top ten, are difficult for SQL. If it is even possible to construct a SQL statement to produce the desired results, such SQL is usually suboptimal.


The result set interface is able to produce the various kinds of data needed for a page of search results all at once, thus improving performance by sharing overhead. The result set interface can also return data views that are difficult to express in SQL, such as top N by category queries.








11.2 Using the XML Query Result Set Interface


The CTX_QUERY.RESULT_SET() API enables you to obtain query results with a single query, rather than running multiple CONTAINS() queries to achieve the same result. For example, in order to display a search result page, the following information needs to be obtained first:


  • 

    top 20 hit list sorted by date and relevancy
    

  • 

    total number of hits for the given Text query
    

  • 

    counts group by publication date
    

  • 

    counts group by author
    



Assume the following table definition for storing documents to be searched:


create table docs (
  docid    number,
  author   varchar2(30),
  pubdate  date,
  title    varchar2(60),  doc      clob);



Assume the following Oracle Text Index definition:


create index docidx on docs(doc) indextype is ctxsys.context
filter by author, pubdate, title,
order by pubdate;



With these definitions, you can obtain the four pieces of information for displaying the search result page by issuing four SQL statements:


-- Get top 20 hits sorted by date and relevancy
select * from
  (select /*+ first_rows */ rowid, title, author, pubdate
   from docs where contains(doc, 'oracle',1)>0
   order by pubdate desc, score(1) desc)
where rownum < 21;
 
-- Get total number of hits for the given Text query
select count(*) from docs where contains(doc, 'oracle',1)>0;
 
-- Get counts group by publication date
select pubdate, count(*) from docs where contains(doc, 'oracle',1)>0 
group by pubdate;
 
-- Get counts group by author
select author, count(*) from docs where contains(doc, 'oracle',1)>0 group by author;



As you can see, using separate SQL statements results in a resource-intensive query, as you run the same query four times. However, by using CTX_QUERY.RESULT_SET(), you can enter all this information in one single Oracle Text query:


declare
   rs clob;
begin
   dbms_lob.createtemporary(rs, true, dbms_lob.session);
   ctx_query.result_set('docidx', 'oracle text performance tuning', '
   <ctx_result_set_descriptor>  
    <count/>
    <hitlist start_hit_num="1" end_hit_num="20" order="pubDate desc, 
        score desc">
      <score/>
      <rowid/>
         <sdata name="title"/>
      <sdata name="author"/>
      <sdata name="pubDate"/>
    </hitlist>
    <group sdata="pubDate">
      <count/>
    </group>
   <group sdata="author">
     <count/>
   </group>
  </ctx_result_set_descriptor>
 ', rs);
 
-- Put in your code here to process the Output Result Set XML
   dbms_lob.freetemporary(rs);
exception
   when others then
    dbms_lob.freetemporary(rs);
    raise;
end;
/



The result set output will be an XML containing all the necessary information required to construct the search result page:


<ctx_result_set>
  <hitlist>
    <hit>
      <score>90</score>
      <rowid>AAAPoEAABAAAMWsAAC</rowid>
      <sdata name="TITLE"> Article 8 </sdata>
      <sdata name="AUTHOR">John</sdata>
      <sdata name="PUBDATE">2001-01-03 00:00:00</sdata>
    </hit>
    <hit>
      <score>86</score>
      <rowid>AAAPoEAABAAAMWsAAG</rowid>
      <sdata name="TITLE"> Article 20 </sdata>
      <sdata name="AUTHOR">John</sdata>
      <sdata name="PUBDATE">2001-01-03 00:00:00</sdata>
    </hit>
    <hit>
      <score>78</score>
      <rowid>AAAPoEAABAAAMWsAAK</rowid>
      <sdata name="TITLE"> Article 17 </sdata>
      <sdata name="AUTHOR">John</sdata>
      <sdata name="PUBDATE">2001-01-03 00:00:00</sdata>
    </hit>
    <hit>
      <score>77</score>
      <rowid>AAAPoEAABAAAMWsAAO</rowid>
      <sdata name="TITLE"> Article 37 </sdata>
      <sdata name="AUTHOR">John</sdata>
      <sdata name="PUBDATE">2001-01-03 00:00:00</sdata>
    </hit>
...
    <hit>
      <score>72</score>
      <rowid>AAAPoEAABAAAMWsAAS</rowid>
      <sdata name="TITLE"> Article 56 </sdata>
      <sdata name="AUTHOR">John</sdata>
      <sdata name="PUBDATE">2001-01-03 00:00:00</sdata>
    </hit>
  </hitlist>
 
  <count>100</count>
 
  <groups sdata="PUBDATE">
    <group value="2001-01-01 00:00:00"><count>25</count></group>
    <group value="2001-01-02 00:00:00"><count>50</count></group>
    <group value="2001-01-03 00:00:00"><count>25</count></group>
  </groups>
 
  <groups sdata="AUTHOR">
    <group value="John"><count>50</count></group>
    <group value="Mike"><count>25</count></group>
    <group value="Steve"><count>25</count></group>
  </groups>
 
</ctx_result_set>










See Also:

Oracle Text Reference for syntax details and more information












PKts%# #PK&AOEBPS/cmigrt.htm#

Migrating Oracle Text Applications



13 Migrating Oracle Text Applications


This chapter covers issues relating to migrating your applications from previous releases of Oracle Text. This chapter contains the following sections:






13.1 Migrating to Oracle Text 11g Release 2 (11.2)


No changes to applications are required when migrating to Oracle Text 11g Release 2 (11.2).








13.2 Migrating to Oracle Text 11g Release 1 (11.1)


No changes to applications are required when migrating to Oracle Text 11g Release 1 (11.1).








13.3 Migrating to Oracle Text 10g Release 2 (10.2)


This section covers issues relating to migrating your applications to Oracle Text 10g Release 2 (10.2). This information is provided for those users who may be upgrading from the next-to-last release of Oracle Text and who want to know what migration steps were required to upgrade to the last release.





13.3.1 New Filter (INSO_FILTER versus AUTO_FILTER)


With Oracle Text 11g Release 1 and later, the INSO_FILTER filter type has been replaced by the AUTO_FILTER filter type. To maintain compatibility with existing Oracle Text applications, INSO_FILTER functionality is supported by AUTO_FILTER, and the INSO_FILTER filter type is being retained, although its behavior has been changed to match that of AUTO_FILTER.


For most users, the change in filter types has no significant effect, and most users do not need to change their applications or otherwise take any steps to migrate to the new filter type. The most significant differences produced by this change are as follows:


  • 

    AUTO_FILTER supports a different set of document types than INSO_FILTER. For a list of supported document types, see the Supported File Formats appendix of Oracle Text Reference.
    

  • 

    Display characteristics of HTML output from the new filter may differ from those output by the old filter.
    

  • 

    A different set of platforms support the AUTO_FILTER type than support INSO_FILTER. For a list of supported platforms, see the Supported File Formats appendix of Oracle Text Reference.
    



Along with the change from INSO_FILTER to AUTO_FILTER, several related changes are also part of the filter migration:


  • 

    The INSO_TIMEOUT and INSO_OUTPUT_FORMATTING attributes of MAIL_FILTER have been replaced by the AUTO_FILTER_TIMEOUT and AUTO_FILTER_OUTPUT_FORMATTING attributes, respectively.
    

  • 

    The INSOFILTER directive used in the mail configuration file of MAIL_FILTER has been replaced with the AUTO_FILTER directive.
    

  • 

    The PL/SQL constant TRACE_IDX_INSO_FILTER for tracing, used in procedures such as CTX_OUTPUT.ADD_TRACE, has been replaced by the TRACE_IDX_AUTO_FILTER filter.
    

  • 

    The system-defined preference CTXSYS.INSO_FILTER has been replaced by the CTXSYS.AUTO_FILTER preference.
    

  • 

    The default values of DEFAULT_FILTER_FILE and DEFAULT_FILTER_BINARY system parameters has been changed from CTXSYS.INSO_FILTER to CTXSYS.AUTO_FILTER for new installations and databases upgrading to this release, if these default values have not been modified. For databases upgrading to this release which have modified these default values, the modified default values will continue to be used.
    



For backward compatibility, INSO_FILTER, as well as most of its associated filter types, constants, and attributes have been retained in this release; however, users should use AUTO_FILTER in new applications and update their older applications whenever possible.





13.3.1.1 Migrating to the AUTO_FILTER Filter Type


Most applications will not have to be modified to reflect the change to the AUTO_FILTER type. The following migration steps will be performed automatically when you upgrade to this release:


  • 

    If an existing index uses the INSO_FILTER filter type, then it will be migrated to the AUTO_FILTER filter type.
    

  • 

    If an existing index uses the MAIL_FILTER filter type, then the INSO_TIMEOUT and INSO_OUTPUT_FORMATTING attributes will be migrated to the AUTO_FILTER_TIMEOUT and AUTO_FILTER_OUTPUT_FORMATTING attributes, respectively.
    

  • 

    If the default values of the system parameters DEFAULT_FILTER_FILE and DEFAULT_FILTER_BINARY have not already been modified, then they will be migrated from CTXSYS.INSO_FILTER to CTXSYS.AUTO_FILTER.
    



Although no actions are required to migrate to the new filter system, Oracle Text users upgrading their databases to this release should take the following steps to migrate away from using APIs deprecated by this release:


  • 

    If an index uses the MAIL_FILTER filter type with a nondefault mail configuration file, edit the file, replacing all occurrences of the INSOFILTER directive with the AUTO_FILTER directive.
    

  • 

    Replace the use of the PL/SQL constant TRACE_IDX_INSO_FILTER in your application with the TRACE_IDX_AUTO_FILTER constant.
    

  • 

    Replace the use of the system-defined preference CTXSYS.INSO_FILTER in your applications with CTXSYS.AUTO_FILTER.
    













PK)##PK&AOEBPS/dcommon/prodbig.gif	GIF87a!!!)))111BBBZZZsss{{ZRRcZZ!!1!91)JB9B9)kkcJJB991ssc絽Zcc!!{祽BZc!9B!c{!)c{9{Z{{cZB1)sJk{{Z{kBsZJ91)Z{!{BcsRsBc{9ZZk甽kBkR!BZ9c)JJc{!))BZks{BcR{JsBk9k)Zck!!BZ1k!ZcRBZcZJkBk1Z9c!R!c9kZRZRBZ9{99!R1{99R{1!1)c1J)1B!BJRkk{ƽ絵ތkk絵RRs{{{{JJsssBBkkk!!9ss{{ZZssccJJZZRRccRRZZ))cBBJJ99JJ!!c11991199Z11!c!!))Z!!!1BRck{)!cJBkZRZ,HP)XRÇEZ֬4jJ0 @	"8pYҴESY3CƊ@*U:lY0_0#
 5tX1E: C_xޘeKTV%ȣOΏ9??:a"\fSrğjAsKJ:nOzO=}E1-I)3(QEQEQEQEQEQEQE֝Hza<["2"pO#f8M[RL(,?g93QSZuy"lx4h`O!LŏʨXZvq& c՚]+:ǵ@+J]tQ]~[[eϸ	(]6A&>ܫ~+כzmZ^(<57KsHf妬Ϧmnẁ&F!:-`b\/(tF*Bֳ~V{WxxfCnMvF=;5_,6%S>}cQQjsOO5=)Ot[W9/{^tyNg#ЄGsֿ1-4ooTZ?K
Gc+oyڙoNuh^iSo5{\ܹ3Yos}$.nQ-~n,-zr~-|K4R"8a{]^;I<ȤL5"EԤP7_j>OoK;*U.at*K[fym3ii^#wcC'IIkIp$󿉵|CtĈpW¹l{9>⪦׺*ͯj.LfGߍԁw] |WW18>w.ӯ!VӃ
:#1~
+މ=;5c__b@W@	+^]ևՃ7	n&g2I8Lw7uҭ$"&"b
eZ":8)D'%{}5{;w]iu;_dLʳ4R-,2H6>½HLKܹR ~foZKZ࿷1[oZ7׫Z7R¢?«'y?A}C_iG5s_~^
J5?œ	tp]X/c'r%eܺA|4ծ-Ե+ْe1M38Ǯ
`|KյOVڅu;"d56, X5kYR<̭CiطXԮ];Oy)OcWj֩}=܅s۸QZ*<~%뺃ȶp f~Bðzb\ݳzW*y{=[
C/Ak	oXCkt_s}{'y?AmCjޓ{
WRV7r. g~Q"7&͹+c<=,dJ1V߁=T)TR՜*N4
^Bڥ%B+=@fE5ka}ędܤFH^i1k\Sgdk>
֤aOM\_\T)8靠㡮3ģR:jj,pk/K!t,=ϯZ6(((((((49
xn_kLk&f9sK`zx{{y8H
8b4>ÇНE|7v(z/]k7IxM}8!ycZRQ
pKVr(RPEr?^}'ðh{x+ՀLW154cK@NgC)rr9+c:׹b	Жf*s^fKS7^}
*{zq_@8#pF~
[VPe(nw0MW=3#kȵz晨cyPpG#W:%drMh]3HH<\]ԁ|_W
HHҡb}P>k{ZErxMX@8C&qskLۙOnO^sCk7ql2XCw5VG.S~H8=(s1~cV5z
%v|U2QF=NoW]ո?<`~׮}=ӬfԵ,=;"~Iy7K#g{ñJ?5$y`
zz@-~m7mG宝Gٱ>G&K#]؃y1$$t>wqjstX.b̐{Wej)Dxfc:8)=$y|L`xV8ߙ~E)HkwW$J0uʟk>6Sgp~;4֌W+חc"=|ř9bc5>	*rg {~cj1rnI#G|8v4wĿhFb><^pJLm[Dl1;Vx5IZ:1*p)إ1ZbAK(1ׅ|S&5{^
KG^5r>;X׻K^?
s	fk^8O/"J)3K]N)iL?5!ƾq:G_=X-
i,vi2N3
|03Qas!7}kZU781M,->e;@Qz
T(GK(ah(((((((Y[×j2F}o־oYYq $+]%$ v^rϭ`nax,ZEuWSܽ,g%~"MrsrY~Ҿ"Fت;8{ѰxYEfP^;WPwqbB:c?zp<7;SBfZ)dϛ;
 7s^>}⍱x?Bix^#hf,*P9S{w[]GF?1Z_nG~]kk)9Sc5Ո<<6J-ϛ}xUi>ux#ţc'{ᛲq?Oo?x&mѱ'#^t)ϲbb0
F«kIVmVsv@}kҡ!ˍUTtxO̧]ORb|2yԵk܊{sPIc_?ħ:Ig)=Z~'
"\M2VSSMyLsl⺿U~"C7\hz_ Rs$~?
TAi<lO*>U}+'f>7_KNs8g1^CeКÿE;{+Y\ O5|Y{/o+LVcO;7Zx-Ek&dpzbӱ+TaB0gNy׭
3^cT\$⫫?F33?t._Q~Nln:U/Ceb1-im
WʸQM+VpafR3d׫é|Aү-q*I P7:y&]hX^Fbtpܩ?|Wu󭏤ʫxJ3ߴm"(uqA}j.+?S
wV~
[B&<^U?rϜ_OH\'.;|.%pw/ZZG'1j(#0UT`Wzw}>_*9m>󑓀F?EL3"zpubzΕ$+0܉&3zڶ+jyr1QE
(
(
(
(
(
(
(
(UIdC0EZm+]Y6^![
ԯsmܶ捆?+me+ZE29)B[;я*wGxsK7;5w)}gH~.Ɣx?X\ߚ}A@tQ(:ͧ|Iq(CT?v[sKG+*רqҍck<#Ljα5݈`8cXP6T5i.K!xX*p&ќZǓϘ7 *oƽ:wlຈ:Q5yIEA/2*2jAҐe}k%K$N9R2?7ýKMV!{W9\PA+c4w`
Wx=Ze\X{}yXI	Ү!aOÎ{]Qx)#D@9E:*NJ}b|Z>_k7:d$z
>&Vv󃏽WlR:RqJfGإd9Tm(ҝEtO}1O[xxEYt8,3vbFF
)ǙrPNE8=O#V*Cc𹾾&l&cmCh<.P{ʦ&ۣY+Gxs~k5$>ӥPquŽўZt~Tl>Q.g> %k#ú:Kn'&{[yWQGqF}AЅ׮/}<;VYZa$wQg!$;_
$NKS}“_{MY|w7G!"\JtRy+贾d|o/;5jz_6fHwk<ѰJ#]kAȎJ=YNu%dxRwwbEQEQEQEQEQEQEQEQEQE'fLQZ(1F)hQ@X1KEQE-Q@	1KE3h=iPb(((1GjZ(-ʹRPbR@	1KE7`bڒyS0(-&)P+	ڎԴP11F)h&:LRmQ@Q@Š((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((([ufT5K9
ر1S^q|&o2R}E"Ȟib!8ct@><7kV$PFC#zepZZǍO $<@(7ĺp^N]IX.@
IHrLKXi2ǁ@h^SY3h$#`pÃ*'ypo3g=EhQ^W'{ƾ4r	ovk-҉5m6R.]B5	|V2]yS9#n@}+CaQn+t
|Pu˝_
Eka͌rYۇ~AhǾg,AZ]G{n9ƀ6(x-h%@WR2#5xAѮTwWI8#>ƀ5(7zwp]ɝA G^ox-5y.д8I$lp~]uzSVa!-P7h(מU3>Vҩzvv Ү`GlNOXỏNs^!hl>.[#{p8}vQX,ޙy%4Kc '# U8m6mRm.-BS|2Qx9^H=hc
wxJ;!9	8Prp?lPEPEPEPEPEPEPEPEPEPEPEPEPEPEPEPEPEPEP^?:*?ֽt>,T
{|a>cķ -,t{;Kvc[s\*r8e<;cĺ~"%ظaM4EqamĐ2cikOMִ7oYJYx
6o[>2uާ>i].%urG˵[Ct?}>K414r@Bǯa^]K6>~AyHs4fcn$=q@Oo_)<dkbYdv|'.TjxÚc'į"cJY(d>fr/N\V|Q|nog^)mVbձZ^54=;-e1YDkюQH!vb11[FW&{<ɭ@V0:)#^ῇ~%}H,hL b:2*{]	O\ٖ18^AnKvI+!I8>5+:[ڮ{[vhfVkroH^ ,dO{po.-jCm\22S|5A$n%G[t"1ޥr=<1/ఛ¾ O/ep/-!
4lKm\o=ppAgV[Ta$	q`1\Ƴ-KG9-Kk0M{{˸[tJɳ'|0t:
h'cR_Qֵ;eے	&OSiEK]G>,xOZ7j:]fH7@F} q~ś/4f$tLPJvcA?-EךW2p:
&<7C+$R/ܳi ;#c8-CİCׇ5ۋy. Id:3 6qq:	C{[($zGp;!m$rN6AWY}Um͙Idx0PN
8(
cteɫF	V	|
" `#cqwT
?NѷxN
A
O+]/Kм,aL72@c6elvrf' )5hylmsL#`
qvG-n.dϿ,mSF3My3᫉lSIkLK&xSXb\gxTM_JVQ\_%#ʄbNJ'uRPJʩ$"8iW-HpGhw#~;/?{+۝{>x]6m5XV{8R4v>7*8n8niڼQHʤ_.Ez
̣'u'sXVtoA˗S>TAȮ??t>T
z&/o3&KXm;$20sWN
A
^%4Jǫb&O-+.Ba1KTWivt&%{c2s$@񅀎G~Rk.'~r1]3o~"mɻȻc=
3d4wï7?Jiw&V‚̪pMc?~~!&E-.ǒ52˞VY?f>vǵ޲*yX}P@&<='CG~=-oj=u卼k*$jX+ u 2iY蚍MDI-0I$	=5'%Uj	!пJ$@(((((((((((((((((({h֞(,{5{3yw
N(WB]4/c_\v.vآ87/Vg\dF`q
g45$͜;Dr:npxESҴK4hdQ'E̒rITAȭh~(,{{H0\y6!ۨ(u.	#"	d"0QӰZ(
6zevvZZǝ$OYѭnȪ};>rN[[ݍ`#sW`ʀ,)8 Ey14O5^'`vDg>a}oryQ$о7#T2@(j&xy#OvӴP c32g~W> MWZ07q<Ler!nvĜhOSmIxC]mtwəZ$
qųxvz˨DoxR2SL(oct$P**
IaY?TUO[־(|M<%z9-S3Uvrř6*Dllb==WxCK<	0kV/bڈTaH`G9g4R贫k10*v;PQ_8|5gYÐ]6UH .Hry
;o4FUUyrbw\d &Ƞ2{P
?C9|AK~N~FAd1,	W'g>YU5yvPt21PQ^7k${kj|KqK2Ī0Tmc݂1g?9egq,B*Y To%/8l3bM\~	Vݵ/R')S,M()V#G(Y}qx7\˺&6*px8 u+iO 4ieؿs˹$
ۗ8'Ce+k2NFb@|zcoiMIw,Nwč#4J|ՕdT+1Vh+V{ui|eU|(
u=kr
Mw˸<5{><L:*Wpz5E|2wKQ}gSO[,KvF63x(*m{q:c}Ey2BH`7d{7Ɲs-j-3zT!׶W{Nş
A`;m㗋5MFUU	pet\T+$>ΤpJ{įz!s/596ԬnS@
r
<RAEPEPEPEPEPEPEPEPEPEP_§FװW㯇?k\C3#~rLw???j3+Z-ܰfHk(,!ِ"R+&q$ke
@yrcrH[?#HI2lqߔFq(~C-sU]Yb\BeC&<9߇z;i=^˼qPx7xBLp~]32"@$Xg8QEzGFK绚	n՘1U\
A֏Þ3)8MO
8X+H4c(w#$"NIpp2Oו>ѯ4r'i{y
C@배AVSkѾ+HRUԶ`7ҫFA*c
 ]g ᧈm"R8P!`>xOS|4dyY'?}|IY-cFHpKg?	-o_8=ݜEY0 9Fp1^M۬ n	wy wXBngz79$X]ZFfH).F72sUoC%Vհ7s	Hk+*#*pFy
ռG4I#C+ qWwOmA”L8.䞾P?>skRLl三!P0WdUC'C?IWq?V4k.H)n@=B	$V};v5soj"As7B:(aG/޴tB-%%)I(p@ "?:*Ʊ>*Igf
@
l#Lo¿
x[FH	PRL)#c,ZFaZ0	TUl<5MWH.50Bt@'>_zuͅ~eOɸzU(xuZmۭ8s0T՜P@++_9;rΝ$ÎHr\3%WJY44	-#-_TiJG82&}p9Pt/
Y]L6/&	#scqIp8,^]9lO7`?$@Z8p	$D߂:e=ܓWhYJnvaA2'<xN[=j&F)$,I PK6[ª;$HIaY?TU|V}lXoV0 Uwt*A9x+M6w455ӫ0bUF0|࿇~5?xU|CiwDʑCrh_,Ȅry}?L\m-c4\Xǁ@kßx{i$p8a׆'5鿳,n[jP*-Pu'<z'-{3󭦟HL+SMմfݮ4Br%*8%I⣿2wGk{uۿb8
\\x_լ7Oo}y+A63l*" tE
×zku{8:@oJ
o^^?	k5]'h>f4Jikv[)el9Aր;Q6xƏ7߷9ܭq`!}oy"2K؃1xM܁`#8Ox+M6w455ӫ0bUF0q~9>xwyBarP$H‚@߉?>}ڞ`NJJ]!1ǁ?xkV)k<9~gA:,wip7ھX]m
fдOiO}+o7n.d82hB((((((((((򿋾%FOKƧĖBDNb.z7;?I;'dyf|yzh(ᯏuw*ykpH`6A$O5PEPEy^jS~Ѿ'.OLGѦc6~U3~fֽR
(
(
(
co6Q<3&7#dr2	V(DӼ96gw}'O&(
(+TuOifnx9ݼ;0JppW
s]ҵ"<$~P.Fs@p2I+4=f:`nYS$ꭂ@`r@Q\kJ&}/5|3@GԴ?XZ7ww%+,@K0Œ/pvMs~)OVEK}J}|;3}@=")|]rwQ
q0:(NM߉4doeG+ɹCW<'}q7C̺5,p8$
(
+㯈Kw~H+y+lc~:񷀼Q
曩JcTM	8jXnܪy$V~^Oe42Gu<\__k^ѵ$m{B6wG!X'dO@EPEPEPEPEPEP\~xGWX uw
ݜvuP/^H =&vy]8#g$Cv=]EPEPEPEPEPEPEPEPEPEPEPn\;*T.\>o[\֗VF=Y,>VRQK?
"]Ywu6-NMx$ATT?8㞃ᇋOQ\08A+:7O|5~5o[&Md"'B.f21#%FGce{Nş
AW>կ}?ixz¿}uE#4r8z]SY|zǻR1}x{c9>s9/k?=OƑB]2Aۛ9`(g'dQWW?O5
`?$](<R?InQtyZ襠(_xzm"|D/"!/ƀ0g{g3|
ݿ廻!_,XI'P@?JwWݟ}n}~'
پO(~lls)d((((((((((((((((((a_JC[Gwim^3ڻ
(?P/Zn6y>1VS|x_9^6NUGCنOAp״6?ĽfOGc+',	dfxKW7wZ[$#88,rO(?N/>(j4?-~F<Uhx_9^6NUGCنOAp״6?ĽfOGc+',	dfxKW7wZ[$#88,rO(/g}o=[ún3k>cԣX6͜9-suK[jàY`!rX'nFk(n_X|>\Z%6,bc'r#
SXF>#nm2$EuឋyuNT!arzdS}/Z͵Fҗ;Ur	e)d@½INѬl.伞8;ePrHSשP|&g%VLoxd3
оxDtdX}dƄ~qHq1ڽbmL|!}}jyvȯr3޴4-3fya۷~83ТSO[!\
*_t
 Exr%*_}!#U
#4
& ֩3|b]L]t b+Da&R_2lEٱZ`aC)/яmvUkS	r(-iPEVv_{z GLt\2s!FA#葡JY
r|AA,hB}q|B`du
}00(䡆<pb,G+oB
C0p/x$…– ]7	@2HFc	)	@AD
\0
LHG',(A``@SC)_"PH`}Y+_|1.K8pAKMA@?3҄$[JPA)+NH I
,@8G0/@RT,`pF8Ѓ)$^$DDTDlA@s;PKPK&AOEBPS/dcommon/darbbook.cssPKPK&A!OEBPS/dcommon/O_signature_clr.JPG"(JFIF``C		

 $.' ",#(7),01444'9=82<.342C			

2!!22222222222222222222222222222222222222222222222222"	
}!1AQa"q2#BR$3br	
%&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz	
w!1AQaq"2B	#3Rbr
$4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz?(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(?O
'~MQ$Vz;OlJi8L%\]UFjޙ%ԯS;rA]5ފ<׈]j7Ouyq$z'TQuw7Ŀ
KX߁M2=S'TQt?.5w'97;~pq=" ~k?`'9q6E|yayM^Om'fkC&<5x'
?A?Zx'jß={=SßM
gVC.5+Hd֪xc^)Җufz{Cީ|DVkznq|+Xa+{50rx{|OG.OϞ~f/	xxX[2H )c+#jpUOZYX\=SGߨC|K@;_߆'e?LT?]:?>w
ڔ`D^So~xo[Ӡ3i7B:Q8Vc-ďoi:FM292~y_*_闱YN\Fr=xZ3鳎OwW_QEzW~c]REeaSM}}Hӏ4&.E]u=gMѠ+mF`rNn$w9gMa꺢nTuhf2Xv>އ
a(Û6߭?<=>z'TQuw7Ŀ
KX߁M2=S'TQt?.5Kko\.8S$TOX߀Gw?Zx汴X)C7~.i6(Щ=+4{mGӭ¸-]&'t_kV*I<1)4thtIsqpQJ+>
\m^[aJ5)ny:4o&QEnyAEPEEss
72,PDۢ׃K
W{Wjr+wگ
iM/;pd?~&?@;7E4gv8
$l'z'TQuw7Ŀ
Gֱ=ɿ&G?.
iR(5W*$|?w᫼gkmIbHe/_t>tg%y.l}N5[]+Mk0ĠeHdPrsst'UiC,y8`V%9ZIia|ܪvi מYG,o}+kk{YbyIeb*sAtի82zWoEK5z*o-eo;n(P	u-I)4Š(HQEQEQEQEhz(X/Đ?}Bk˩ݏrk0]4>8XzV?
}6$}d^F>nU	K	?Bտk_9׾x~w'ߞ		uDŽtL؈5c-E/"|_Oo.IH쐍=i*Iw5(ںw?t5s.)+tQ2dUt5Vĺ.jZ"@IRrZƅY4ߡ_;}ų(KyQf1Aǵt?sZg+?F5_oQR&Dg߿]6FuRDu>ڿxl7?IT8'shj^=.=J1rj1Wl$얲cPx;E,p$֟ˏkw qg"45(ǛkV/=+ũ)bYl~K#˝J_כ5&\F'I#8/|wʾ_Xj
Q:os^T1.M_|TO.;?_jF?g
N8nA2F%i=qW,G=5OU u8]Rq?wr'˻S+۾.ܼ
87Q^elo/T*?L|ۚ<%<,/v_OKs
B5f/29n0=zqQq(ª=VX@*J(э(f5qJN_EVǞQEOuoѕOuoa5}gO?:߂8Wא|cڽ~]N&O(
(<]>͠@VQ=^~U	̴m&\խ5i:}|}r~9՝f}_>'vVֲ$~^f30^in{\_.OF8to}?${φ|#x^#^n~w=~k~?'KRtO.㌡h![3Zu*ٷճ(ԟ]z_/W1(ԟ]v~g|Yq<ז0
;	b8֮s,w9\?uEyStKaª@\,))
(!EPEPEPEPEPzѧts{v>C/"N6`d*J2gGӧWqBq_1ZuΓ\X]r?=Ey88Mp&pKtO-"wR2
K^-Z<\c>V0^@O7x2WFjs<׻kZ(<Т(OFw/6$1[:ޯԯ#q~4|,LVPem=@=YLUxӃV}AUbcUB.Ds5*kٸAeG>PJxt͝	b88?*$~@ׯDVkraiJs}Q.20x&mXξ,Z]“A-J#`+-E/"<]\a'tZGy.(|lދ~gMK
OZdxDŽU9T6ϯ^<Ϡt5CZ]].t۫S=s`ڳ%8iVK:nqe+#<.T6U>zWoy3^I	{F?J~=G}k)K$$;$de8*G Uӟ4Ocºw}|]4=ݣ\x$ʠms?q^ipw\"ȿPs^ZQ_0GڼU.t}ROM[G#]8wٞӫ87}Cgw
vHȩBM55vof	=A_٭`Ygx[6P,5}>蚊(0(+?>+?>k|TuXq6_ +szk
:u_Z߶Ak_U}Jc2u/1[_»ݸG41-bሬ۴}}Eȹפ_c?5gi
@cL\L<68hF_Ih>X4K7UТ	sMj	=J7CKo>Օ5s:߀t
~ηaٿ?|gdL8+gG%o?x`دOqȱwc¨&TW_V_aI=dpG!wu۞սZ1yL50$(l3(:~'ַo
A}a3N*[0ǭ HKQV}G@֜$
9of$ArNqUOgË05#m?D)^_h//5_/<?4}Jį+GkpG4"$ 	r|>S4Ђ"S
1%R:ȝ 8;PKPzPK&AOEBPS/dcommon/feedback.gif7GIF89a'%(hp|fdx?AN5:dfeDGHɾTdQc`g*6DC\?ؘ||{;=E6JUՄfeA=>@,4`H.|`a	(Q 9:&[|ځ,4p Y&BDb,!2@,
$wPA'ܠǃ@CO~/d.`I @8ArHx9H75j L	3B/`	P#qD*s3A:3,H70P,R@ p!(Foԥ D;"0,6QBRɄHhI@@VDLCk8@NBBL2&pClA?DAk%$`I2
#Q+l7 "=&dL&PRSLIP)PɼirqМ'N8[_}w;PK-PK&AOEBPS/dcommon/booklist.gifGIF89a1޵֥΄kZ{Jk1Rs!BZ)B),@I9Z͓Ca%	Dz8Ȁ0FZЌ0P!x8!eL8aWȠFD(~@p+rMS|ӛR$v
"Z:]ZJJEc{*=AP
	BiA']j4$*
&	9qsMiO?jQ	=	
	, YFg4.778c&$c%9;PKː5PK&AOEBPS/dcommon/cpyr.htm1

Oracle Legal Notices

Oracle Legal Notices


Copyright Notice


Copyright © 1994-2012, Oracle and/or its affiliates. All rights reserved.


Trademark Notice


Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.


Intel and Intel Xeon are trademarks or registered trademarks of Intel Corporation. All SPARC trademarks are used under license and are trademarks or registered trademarks of SPARC International, Inc. AMD, Opteron, the AMD logo, and the AMD Opteron logo are trademarks or registered trademarks of Advanced Micro Devices. UNIX is a registered trademark of The Open Group.


License Restrictions Warranty/Consequential Damages Disclaimer


This software and related documentation are provided under a license agreement containing restrictions on use and disclosure and are protected by intellectual property laws. Except as expressly permitted in your license agreement or allowed by law, you may not use, copy, reproduce, translate, broadcast, modify, license, transmit, distribute, exhibit, perform, publish, or display any part, in any form, or by any means. Reverse engineering, disassembly, or decompilation of this software, unless required by law for interoperability, is prohibited.


Warranty Disclaimer


The information contained herein is subject to change without notice and is not warranted to be error-free. If you find any errors, please report them to us in writing.


Restricted Rights Notice


If this is software or related documentation that is delivered to the U.S. Government or anyone licensing it on behalf of the U.S. Government, the following notice is applicable:


U.S. GOVERNMENT RIGHTS Programs, software, databases, and related documentation and technical data delivered to U.S. Government customers are "commercial computer software" or "commercial technical data" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, the use, duplication, disclosure, modification, and adaptation shall be subject to the restrictions and license terms set forth in the applicable Government contract, and, to the extent applicable by the terms of the Government contract, the additional rights set forth in FAR 52.227-19, Commercial Computer Software License (December 2007). Oracle America, Inc., 500 Oracle Parkway, Redwood City, CA 94065.


Hazardous Applications Notice


This software or hardware is developed for general use in a variety of information management applications. It is not developed or intended for use in any inherently dangerous applications, including applications that may create a risk of personal injury. If you use this software or hardware in dangerous applications, then you shall be responsible to take all appropriate fail-safe, backup, redundancy, and other measures to ensure its safe use. Oracle Corporation and its affiliates disclaim any liability for any damages caused by use of this software or hardware in dangerous applications.


Third-Party Content, Products, and Services Disclaimer


This software or hardware and documentation may provide access to or information on content, products, and services from third parties. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to third-party content, products, and services. Oracle Corporation and its affiliates will not be responsible for any loss, costs, or damages incurred due to your access to or use of third-party content, products, or services.


Alpha and Beta Draft Documentation Notice


If this document is in prerelease status:


This documentation is in prerelease status and is intended for demonstration and preliminary use only. It may not be specific to the hardware on which you are using the software. Oracle Corporation and its affiliates are not responsible for and expressly disclaim all warranties of any kind with respect to this documentation and will not be responsible for any loss, costs, or damages incurred due to the use of this documentation.


Oracle Logo


PKN61PK&AOEBPS/dcommon/masterix.gif.GIF89a1ޜΌscJk1Rs!Bc1J),@IS@0"1 Ѿb$b08PbL,acr
B@(fDnJx11+\%1 p {
	display: none;
}

/* Class Selectors */

.ProductTitle {
	font-family: sans-serif;
}

.BookTitle {
	font-family: sans-serif;
}

.VersionNumber {
	font-family: sans-serif;
}

.PrintDate {
	font-family: sans-serif;
	font-size: small;
}

.PartNumber {
	font-family: sans-serif;
	font-size: small;
}
PKeӺ1,PK&AOEBPS/dcommon/larrow.gif#GIF87a絵ƌֵƽ{{ss֜ƔZZ{{{{ZZssZZccJJJJRRBBJJJJ991111))!!{,@pH,Ȥrl:ШtpHc`

өb[.64ꑈ53=Z]'yuLG*)g^!8C?-6(29K"Ĩ0Яl;U+K9^u2,@@(\ȰË$P`lj8x I$4H	*(@͉0dа8tA
DсSPv"TUH	PhP"Y1bxDǕ̧_=$I/&
.)+	60D)bB~=0#'& *D+l1MGCL1&+D`.1qVG( "D2QL,p.;u.
|r$p+5qBNl<TzB"\9e0u
)@D,¹2@C~KU
'L6a9 /;<`P!D#Tal6XTYhn[p]݅	7}B	a&AƮe{EɲƮiEp#G}D#xTIzGFǂEc^q})	Y# (tۮNeGL*@/%UB:&k0{	&SdDnBQ^("@q #`	@1B4i@
aNȅ@[\B
>e007V[N(vpyFe
Gb/&|aHZj@""~ӎ)t?	$
EQ.սJ$C,l]A `8A o
B
C?8cyA
@Nz|`:`~7-G|yQAqA6OzPbZ`>~#8=./edGA2nrBYR@
W
h'j4p'!k00MTRNF6̙
m`
(7%ꑀ;PKl-OJPK&AOEBPS/dcommon/index.gifGIF89a1޵ΥΥ{sc{BZs,@IM" ADB0
3.R~[D"0,]ШpRNC	 /&H&[%7TM/`vS+-+q

D
	go@"	4o'Uxcxcc&k/
qp
zUm(UHDDJBGMԃ;PK(PK&AOEBPS/dcommon/bookbig.gif	+GIF89a$!!!)))111999BBBJJJRRRZZZccckkksss{{{skkB991)))!!B11))1!JB9B9!!cZ9ƭƽssk{ZZRccZRRJJJBBB9c!!ν)1)k{s絽ƌkssֽZccJRRBJJ{9BB)11)99!!))11!!k!JZ!)RcJccBcs)1c)JZ!BR!)BZ)99J!Rk9!c11B)Z{)9Bkc1kB9BZ!Z{9Rs)Jkksk9kB1s1Jk9Rƥc{k9s)Z{1k91)s1Rk)Jc1J!))BZ!1k{csc{)19B!)Bcsc{ksc{kZs!RkJkJkքc{9Zks{ck9R)Bks9R9R1J!)Z1B!)c)9)99BR19kksBBJcc{ccBBZ))9kk!!199c11ZBB{9!!R!!Z!!c))!!kR!!s!!BcksRZ1c9B)R91c1)Z!R9B9k1)RcZ{)!1B9JB9B)!)J9B!&  Imported from GIF image: bookbig.gif,$!!!)))111999BBBJJJRRRZZZccckkksss{{{skkB991)))!!B11))1!JB9B9!!cZ9ƭƽssk{ZZRccZRRJJJBBB9c!!ν)1)k{s絽ƌkssֽZccJRRBJJ{9BB)11)99!!))11!!k!JZ!)RcJccBcs)1c)JZ!BR!)BZ)99J!Rk9!c11B)Z{)9Bkc1kB9BZ!Z{9Rs)Jkksk9kB1s1Jk9Rƥc{k9s)Z{1k91)s1Rk)Jc1J!))BZ!1k{csc{)19B!)Bcsc{ksc{kZs!RkJkJkքc{9Zks{ck9R)Bks9R9R1J!)Z1B!)c)9)99BR19kksBBJcc{ccBBZ))9kk!!199c11ZBB{9!!R!!Z!!c))!!kR!!s!!BcksRZ1c9B)R91c1)Z!R9B9k1)RcZ{)!1B9JB9B)!)J9BH`\Ȑ:pظа"A6DBH,V@Dڹ'G"v Æ ܥ;n;!;>xAܽ[G.\rQCwr}BŊQ A9ᾑ#5Y0VȒj0l-GqF>ZpM
rb;=.ސW-WѻWo	ha!}~ْ; t53:\4PcD,0 4*_l0K3-`l.j!c Aa|2L4/1C`@@md;(H*80L0L(h*҇҆o#N84pC (xO@ A)J6rVlFr	fry†$r_pl5xhA+@A=F rGU	a
1х4s&H Bdzt x#H%Rr
(Ѐ7P`#Rщ'x"	#0`@~i
`HA'Tk?3!$`-A@1l"PLhʖRG&8A`0DcBH sq@AXB4@&yQhPAppxCQ(rBW00@DP1E?@lP1%T`0 WB~nQ@;PKGC		PK&AOEBPS/dcommon/rarrow.gif/GIF87a絵ƌֵƽ{{ss֜ƔZZ{{{{ZZssZZccJJJJRRBBJJJJ991111))!!{,@pH,Ȥrl:ШLlԸ
NCqWEd)#34vwwpN|0yhX!'+-[F	'n5H	$/14w3%
C	.90"	qF7&E"D	mnB|,c96)I	@0BW{ᢦdNp!5"D`0T0-]ʜ$;PKJV^PK&AOEBPS/dcommon/mix.gifkGIF89aZZZBBBJJJkkk999sss!!!111cccֽ{{{RRR)))猌ƭ{s{sks!,@@pH,B$
8
t:<8
*'ntPP DQ@rIBJLNPTVEMOQUWfj^!
hhGH
kCúk_a
Ǥ^h`B		BeH
mm	#F`
I
lpǎ,p BJ\Y!T\(dǏ!Gdˆ
R53ټ	R;iʲ)G=@-xn.4Y	BuU(*BL0PX
v`[D! |
>!/;xP`	(Jj"M6 ;PK枰pkPK&AOEBPS/dcommon/doccd_epub.jsM
/*
  Copyright 2006, 2012, Oracle and/or its affiliates. All rights reserved.
  Author: Robert Crews
  Version: 2012.3.17
*/

function addLoadEvent(func) {
  var oldOnload = window.onload;
  if (typeof(window.onload) != "function")
    window.onload = func;
  else
    window.onload = function() { oldOnload(); func(); }
}

function compactLists() {
  var lists = [];
  var ul = document.getElementsByTagName("ul");
  for (var i = 0; i < ul.length; i++) lists.push(ul[i]);
  var ol = document.getElementsByTagName("ol");
  for (var i = 0; i < ol.length; i++) lists.push(ol[i]);

  for (var i = 0; i < lists.length; i++) {
    var collapsible = true, c = [];
    var li = lists[i].getElementsByTagName("li");
    for (var j = 0; j < li.length; j++) {
      var p = li[j].getElementsByTagName("p");
      if (p.length > 1) collapsible = false;
      for (var k = 0; k < p.length; k++) {
        if ( getTextContent(p[k]).split(" ").length > 12 ) collapsible = false;
        c.push(p[k]);
      }
    }
    if (collapsible) {
      for (var j = 0; j < c.length; j++) {
        c[j].style.margin = "0";
      }
    }
  }

  function getTextContent(e) {
    if (e.textContent) return e.textContent;
    if (e.innerText) return e.innerText;
  }
}
addLoadEvent(compactLists);

function processIndex() {
  try {
    if (!/\/index.htm(?:|#.*)$/.test(window.location.href)) return false;
  } catch(e) {}

  var shortcut = [];
  lastPrefix = "";

  var dd = document.getElementsByTagName("dd");
  for (var i = 0; i < dd.length; i++) {
    if (dd[i].className != 'l1ix') continue;
    var prefix = getTextContent(dd[i]).substring(0, 2).toUpperCase();
    if (!prefix.match(/^([A-Z0-9]{2})/)) continue;
    if (prefix == lastPrefix) continue;
    dd[i].id = prefix;
    var s = document.createElement("a");
    s.href = "#" + prefix;
    s.appendChild(document.createTextNode(prefix));
    shortcut.push(s);
    lastPrefix = prefix;
  }

  var h2 = document.getElementsByTagName("h2");
  for (var i = 0; i < h2.length; i++) {
    var nav = document.createElement("div");
    nav.style.position = "relative";
    nav.style.top = "-1.5ex";
    nav.style.left = "1.5em";
    nav.style.width = "90%";
    while (shortcut[0] &&
      shortcut[0].toString().charAt(shortcut[0].toString().length - 2) ==
      getTextContent(h2[i])) {
      nav.appendChild(shortcut.shift());
      nav.appendChild(document.createTextNode("\u00A0 "));
    }
    h2[i].parentNode.insertBefore(nav, h2[i].nextSibling);
  }

  function getTextContent(e) {
    if (e.textContent) return e.textContent;
    if (e.innerText) return e.innerText;
  }
}
addLoadEvent(processIndex);
PKo"nR
M
PK&AOEBPS/dcommon/toc.gifGIF89a1ΥΥ{c{Z{JkJk1Rk,@IK% 0| eJB,K-1i']Bt9dz0&pZ1o'q(؟dQ=3S
SZC8db f&3v2@VPsuk2Gsiw`"IzE%<C!.hC
IQ 3o?39T
ҍ;PKv
I
PK&AOEBPS/dcommon/topnav.gifGIF89a1ֽ筽ޭƔkZZk{Bc{,@	) l)-'KR$&84 SI)	XF
 P8te	NRtHPp;Q%Q@'#rR4P fSQ
o0MX[)
v+
`i9gda/&L9i*1$#"%+
(
E'
n7Ȇ(,҅(L@(Q$\x8=6'נ9tJ&"[Epljt
p#ѣHb:f
F`A
=l|;&9lDP2ncH
R`qtp!dȐYH›+?$4mBA9	i@@]@ꃤFxAD*^Ŵ#,(ε	
$H}F.xf,BD
Z;PK1FAPK&AOEBPS/dcommon/bp_layout.css#
@charset "utf-8";
/*
  bp_layout.css
  Copyright 2007, Oracle and/or its affiliates. All rights reserved.
*/

body {
  margin: 0ex;
  padding: 0ex;
}
h1 {
  display: none;
}
#FOOTER {
  border-top: #0d4988 solid 10px;
  background-color: inherit;  
  color: #e4edf3;  
  clear: both;
}
#FOOTER p {
  font-size: 80%;
  margin-top: 0em;
  margin-left: 1em;
}
#FOOTER a {
  background-color: inherit;
  color: gray;  
}
#LEFTCOLUMN {
  float: left;
  width: 50%;
}
#RIGHTCOLUMN {
  float: right;
  width: 50%;
  clear: right; /* IE hack */
}
#LEFTCOLUMN div.portlet {
  margin-left: 2ex;
  margin-right: 1ex;
}
#RIGHTCOLUMN div.portlet {
  margin-left: 1ex;
  margin-right: 2ex;
}
div.portlet {
  margin: 2ex 1ex;
  padding-left: 0.5em;
  padding-right: 0.5em;
  border: 1px #bcc solid;
  background-color: #f6f6ff;
  color: black;
}
div.portlet h2 {
  margin-top: 0.5ex;
  margin-bottom: 0ex;
  font-size: 110%;
}
div.portlet p {
  margin-top: 0ex;
}
div.portlet ul {
  list-style-type: none;
  padding-left: 0em;
  margin-left: 0em; /* IE Hack */
}
div.portlet li {
  text-align: right;
}
div.portlet li cite {
  font-style: normal;
  float: left;
}
div.portlet li a {
  margin: 0px 0.2ex;
  padding: 0px 0.2ex;
  font-size: 95%;
}
#NAME {
  margin: 0em;
  padding: 0em;
  position: relative;
  top: 0.6ex;
  left: 10px;
  width: 80%;
}
#PRODUCT {
  font-size: 180%;
}
#LIBRARY {
  color: #0b3d73;
  background: inherit;
  font-size: 180%;
  font-family: serif;
}
#RELEASE {
  position: absolute;
  top: 28px;
  font-size: 80%;
  font-weight: bold;
}
#TOOLS {
  list-style-type: none;
  position: absolute;
  top: 1ex;
  right: 2em;
  margin: 0em;
  padding: 0em;
  background: inherit;
  color: black;
}
#TOOLS a {
  background: inherit;
  color: black;
}
#NAV {
  float: left;
  width: 96%;
  margin: 3ex 0em 0ex 0em;
  padding: 2ex 0em 0ex 4%; /* Avoiding horizontal scroll bars. */
  list-style-type: none;
  background: transparent url(../gifs/nav_bg.gif) repeat-x bottom;
}
#NAV li {
  float: left;
  margin: 0ex 0.1em 0ex 0em;
  padding: 0ex 0em 0ex 0em;
}
#NAV li a {
  display: block;
  margin: 0em;
  padding: 3px 0.7em;
  border-top: 1px solid gray;
  border-right: 1px solid gray;
  border-bottom: none;
  border-left: 1px solid gray;
  background-color: #a6b3c8;
  color: #333;
}
#SUBNAV {
  float: right;
  width: 96%;
  margin: 0ex 0em 0ex 0em;
  padding: 0.1ex 4% 0.2ex 0em; /* Avoiding horizontal scroll bars. */
  list-style-type: none;
  background-color: #0d4988;
  color: #e4edf3;  
}
#SUBNAV li {
  float: right;
}
#SUBNAV li a {
  display: block;
  margin: 0em;
  padding: 0ex 0.5em;
  background-color: inherit;
  color: #e4edf3;
}
#SIMPLESEARCH {
  position: absolute;
  top: 5ex;
  right: 1em;
}
#CONTENT {
  clear: both;
}
#NAV a:hover,
#PORTAL_1 #OVERVIEW a,
#PORTAL_2 #OVERVIEW a,
#PORTAL_3 #OVERVIEW a,
#PORTAL_4 #ADMINISTRATION a,
#PORTAL_5 #DEVELOPMENT a,
#PORTAL_6 #DEVELOPMENT a,
#PORTAL_7 #DEVELOPMENT a,
#PORTAL_11 #INSTALLATION a,
#PORTAL_15 #ADMINISTRATION a,
#PORTAL_16 #ADMINISTRATION a {
  background-color: #0d4988;
  color: #e4edf3;
  padding-bottom: 4px;
  border-color: gray;
}

#SUBNAV a:hover,
#PORTAL_2 #SEARCH a,
#PORTAL_3 #BOOKS a,
#PORTAL_6 #WAREHOUSING a,
#PORTAL_7 #UNSTRUCTURED a,
#PORTAL_15 #INTEGRATION a,
#PORTAL_16 #GRID a {
  position: relative;
  top: 2px;
  background-color: white;
  color: #0a4e89;
}
PK3(
#
PK&AOEBPS/dcommon/bookicon.gif:GIF87a!!!)))111999BBBJJJRRRZZZccckkksss{{{ޭ{{ZRRcZZRJJJBB)!!skRB9{sν{skskcZRJ1)!֭ƽ{ZZRccZJJBBB999111)JJ9BB1ZZB!!ﭵBJJ9BB!!))Jk{)1!)BRZJ{BsR!RRJsJ!J{s!JsBkks{RsB{J{c1RBs1ZB{9BJ9JZ!1BJRRs!9R!!9Z9!1)J19JJRk19R1Z)!1B9R1RB!)J!J1R)J119!9J91!9BkksBBJ119BBR!))9!!!JB1JJ!)19BJRZckތ1)1J9B,H*\hp >"p`ƒFF
"a"E|ժOC&xCRzOBtX>XE*O>tdqAJ	+,WxP!CYpQ
HQzDHP)T
njJM2ꔀJ2T0d#+I:<жk
'ꤱFAB
@@nh
Wz' H|-7f\A#yNR5	/PM09u
UjćT|q~Yq@&0YZAPa`EzI/$AD Al!AAal2H@$PVAB&c*ؠ p
@%
p-`@b`uBal&`3Ap8槖X~	vX$Eh`.JhAepA\"Bl,	:Hk;PKx[?:PK&AOEBPS/dcommon/conticon.gif^GIF87a!!!)))111999BBBJJJRRRZZZccckkksss{{{ZRR޽{{ssskkkcccZ991ccRZZBBJJZck)19ZcsBJZ19J!k{k)Z1RZs1!B)!J91{k{)J!B!B911)k{cs!1s!9)s!9!B!k)k1c!)Z!R{9BJcckZZcBBJ99B119{{!!)BBRBBZ!))999R99Z!!999c1!9!)19B1)!B9R,oua\h2SYPa
aowwxYi	9SwyyxxyYSd$'^qYȵYvh
ч,/?g{н.J5fe{ڶyY#%/}‚e,Z|pAܠ
`KYx,ĉ&@iX9|`p ]lR1khٜ'E 6ÅB0J;tX bRP(*MÄ!2cLhPC <0Ⴁ

$4!B6lHC%<1e
H4p"
L`P!/,m*1F`#D0D^!AO@..(``_؅QWK>_*OY0J@pw'tVh;PKp*c^PK&AOEBPS/dcommon/blafdoc.cssL@charset "utf-8";
/*
  Copyright 2002, 2011, Oracle and/or its affiliates. All rights reserved.
  Author: Robert Crews
  Version: 2011.10.7
*/

body {
  font-family: Tahoma, sans-serif;
/*  line-height: 125%; */
  color: black;
  background-color: white;
  font-size: small;
}
* html body {
  /* http://www.info.com.ph/~etan/w3pantheon/style/modifiedsbmh.html */
  font-size: x-small; /* for IE5.x/win */
  f\ont-size: small;  /* for other IE versions */
}

h1 {
  font-size: 165%;
  font-weight: bold;
  border-bottom: 1px solid #ddd;
  width: 100%;
}

h2 {
  font-size: 152%;
  font-weight: bold;
}

h3 {
  font-size: 139%;
  font-weight: bold;
}

h4 {
  font-size: 126%;
  font-weight: bold;
}

h5 {
  font-size: 113%;
  font-weight: bold;
  display: inline;
}

h6 {
  font-size: 100%;
  font-weight: bold;
  font-style: italic;
  display: inline;
}

a:link {
  color: #039;
  background: inherit;
}

a:visited {
  color: #72007C;
  background: inherit;
}

a:hover {
  text-decoration: underline;
}

a img, img[usemap] {
  border-style: none;
}

code, pre, samp, tt {
  font-family: monospace;
  font-size: 110%;
}

caption {
  text-align: center;
  font-weight: bold;
  width: auto;
}

dt {
  font-weight: bold;
}

table {
  font-size: small; /* for ICEBrowser */
}

td {
  vertical-align: top;
}

th {
  font-weight: bold;
  text-align: left;
  vertical-align: bottom;
}

ol ol {
  list-style-type: lower-alpha;
}

ol ol ol {
  list-style-type: lower-roman;
}

td p:first-child, td pre:first-child {
  margin-top: 0px;
  margin-bottom: 0px;
}

table.table-border {
  border-collapse: collapse;
  border-top: 1px solid #ccc;
  border-left: 1px solid #ccc;
}
table.table-border th {
  padding: 0.5ex 0.25em;
  color: black;
  background-color: #f7f7ea;
  border-right: 1px solid #ccc;
  border-bottom: 1px solid #ccc;
}
table.table-border td {
  padding: 0.5ex 0.25em;
  border-right: 1px solid #ccc;
  border-bottom: 1px solid #ccc;
}

span.gui-object, span.gui-object-action {
  font-weight: bold;
}

span.gui-object-title { }

p.horizontal-rule {
  width: 100%;
  border: solid #cc9;
  border-width: 0px 0px 1px 0px;
  margin-bottom: 4ex;
}

div.zz-skip-header {
  display: none;
}

td.zz-nav-header-cell {
  text-align: left;
  font-size: 95%;
  width: 99%;
  color: black;
  background: inherit;
  font-weight: normal;
  vertical-align: top;
  margin-top: 0ex;
  padding-top: 0ex;
}

a.zz-nav-header-link {
  font-size: 95%;
}

td.zz-nav-button-cell {
  white-space: nowrap;
  text-align: center;
  width: 1%;
  vertical-align: top;
  padding-left: 4px;
  padding-right: 4px;
  margin-top: 0ex;
  padding-top: 0ex;
}

a.zz-nav-button-link {
  font-size: 90%;
}

div.zz-nav-footer-menu {
  width: 100%;
  text-align: center;
  margin-top: 2ex;
  margin-bottom: 4ex;
}

p.zz-legal-notice, a.zz-legal-notice-link {
  font-size: 85%;
  /* display: none; */ /* Uncomment to hide legal notice */
}

/*************************************/
/*  Begin DARB Formats               */
/*************************************/

.bold, .codeinlinebold, .syntaxinlinebold, .term, .glossterm, .seghead,
.glossaryterm, .keyword, .msg, .msgexplankw, .msgactionkw, .notep1,
.xreftitlebold {
  font-weight: bold;
}

.italic, .codeinlineitalic, .syntaxinlineitalic, .variable,
.xreftitleitalic {
  font-style: italic;
}

.bolditalic, .codeinlineboldital, .syntaxinlineboldital,
.titleinfigure, .titleinexample, .titleintable, .titleinequation,
.xreftitleboldital {
  font-weight: bold;
  font-style: italic;
}

.itemizedlisttitle, .orderedlisttitle, .segmentedlisttitle,
.variablelisttitle {
  font-weight: bold;
}

.bridgehead, .titleinrefsubsect3 {
  font-weight: bold;
}

.titleinrefsubsect {
  font-size: 126%;
  font-weight: bold;
}

.titleinrefsubsect2 {
  font-size: 113%;
  font-weight: bold;
}

.subhead1 {
  display: block;
  font-size: 139%;
  font-weight: bold;
}

.subhead2 {
  display: block;
  font-weight: bold;
}

.subhead3 {
  font-weight: bold;
}

.underline {
  text-decoration: underline;
}

.superscript {
  vertical-align: super;
}

.subscript {
  vertical-align: sub;
}

.listofeft {
  border: none;
}

.betadraft, .alphabetanotice, .revenuerecognitionnotice {
  color: #e00;
  background: inherit;
}

.betadraftsubtitle {
  text-align: center;
  font-weight: bold;
  color: #e00;
  background: inherit;
}

.comment {
  color: #080;
  background: inherit;
  font-weight: bold;
}

.copyrightlogo {
  text-align: center;
  font-size: 85%;
}

.tocsubheader {
  list-style-type: none;
}

table.icons td {
  padding-left: 6px;
  padding-right: 6px;
}

.l1ix dd, dd dl.l2ix, dd dl.l3ix {
  margin-top: 0ex;
  margin-bottom: 0ex;
}

div.infoboxnote, div.infoboxnotewarn, div.infoboxnotealso {
  margin-top: 4ex;
  margin-right: 10%;
  margin-left: 10%;
  margin-bottom: 4ex;
  padding: 0.25em;
  border-top: 1pt solid gray;
  border-bottom: 1pt solid gray;
}

p.notep1 {
  margin-top: 0px;
  margin-bottom: 0px;
}

.tahiti-highlight-example {
  background: #ff9;
  text-decoration: inherit;
}
.tahiti-highlight-search {
  background: #9cf;
  text-decoration: inherit;
}
.tahiti-sidebar-heading {
  font-size: 110%;
  margin-bottom: 0px;
  padding-bottom: 0px;
}

/*************************************/
/*  End DARB Formats                 */
/*************************************/

@media all {
/*
  * * {
    line-height: 120%;
  }
*/
  dd {
    margin-bottom: 2ex;
  }
  dl:first-child {
    margin-top: 2ex;
  }
}

@media print {
  body {
    font-size: 11pt;
    padding: 0px !important;
  }

  a:link, a:visited {
    color: black;
    background: inherit;
  }

  code, pre, samp, tt {
    font-size: 10pt;
  }

  #nav, #search_this_book, #comment_form,
  #comment_announcement, #flipNav, .noprint {
    display: none !important;
  }

  body#left-nav-present {
    overflow: visible !important;
  }
}
PKʍPK&AOEBPS/dcommon/rightnav.gif&GIF89a1ֽ筽ޭƔkZZk{Bc{,@	) l)-
$CҠҀ !	D1#:aS(	c4B0
AC8
ְ9!%MLj
Z*ctypJBa
H
t>#Sb(clhUԂ̗4DztSԙ9ZQҀEPEPEPEPEPEPEPM=iԍP	Giic*yF1׆@\&o!QY00_rlgV;)DGhCq7~..p&1c:u֫{fI>fJL$}BBP?JRWc<^j+χ5b[hֿ-
5_j?POkeQ^hֿ1L^
H
?Qi?z?+_xɔŪ\썽O]χ>)xxV/s)e6MI7*ߊޛv֗2J,;~E4yi3[nI`Ѱe9@zXF*W+]7QJ$$=&`a۾?]N
T䏟'X)Ɣkf:j
|>NBWzYx0t!*_KkoTZ?K
Gc+UyڹgNuh^iSo5{\ܹ3Yos}.>if FqR5\/TӮ#]HS0DKu{($"2xִ{SBJ8=}Y=.|Tsц2UЫ%.InaegKo
z
ݎ3ֹxxwM&2S%';+I',kW&-"_¿_
Vq^ܫ6pfT2RV
A^6RKetto^[{w\jPZ@ޢN4/XN#\42j\(z'j=~-I#:q[Eh|X:sp*bifp$TspZ-}NM*B-bb&*xUr#*$M|QWY
~p~-
fTED6O.#$m+t$˙H"Gk=t9r娮Y?
CzE[/*-{c*[w~o_?%ƔxZ:/5𨴟q}/]22p
qD\H"K]ZMKR&\C3zĽ[PJm]AS)Ia^km
M@dК)fT[ijW*hnuͲiw/bkExG£@f?Zu.s0(<`0ֹoxOaDx\zT-^ѧʧ_1+CP/p[w
9~U^[U<[tĽwPv[yzD1W='u$Oeak[^	|Gk2xv#2?¹TkSݕ|	rݞ[Vi_Kz*{\c(Ck_܏|?ujVڔ6ft?3nmZ6f%QAjJf9Rq
_j7Z-y.pG$Xb]0')[_k;$̭?&"0FOew7 z-cIX岛;$u=\an$zmrILu
uٞ%
_1xcUW%dtÀx885Y^gn;}ӭ)場QEQ@Q@Q@Q@Q@Q@!4xPm3w*]b`F_931˜[ן+(>
E ly;<;MF-qst+}DH
@YKlLmؤciN<|]IU)Lw(8t9FS(=>og<\Z~u_+X1ylsj'eՃ*U3`C!N9Q_WܱhKc93^ua>H	ƕGk=8~e#_?{ǀe-[2ٔ7;=&K挑5zsLdx(e8#{1wS+ΝVkXq9>&yஏh$zq^0~/j@:/«Vnce$$uoPp}MC{$-akH@ɫ1O !8R9s5ԦYmϧ'OUṡ5T,!Ԛ+s#1Veo=[)g>#<s)ƽُA^䠮ωFUj(ǩ|N3Jڷ睁ϱuږZYGOTsI<&drav?A^_f׻B$,O__ԿC`it{6>G׈C~&$y؎v1q9Sc1fH[ѽ>,gG'0'@Vw,BO
[#>ﱺg5ΒFVD%Yr:O5
Tu+O멃]ی38Ze}R&ѝ_xzc1DXgس;<,_,{ƽY'AS#oF.M#~cBuEx7G+Y)(5q+GCV;qF+CLQ)qEC&6z𿊘z}?&w=+)??&\g{;V??׻xGœdٿ׼-Nc')3K]N)iLTӿCdb7Q^aNsd>Fz[0S^s'Zi
 77D}kWusab~~H(>.fif9,~|Jk;YN3H8Y(t6Q݉k͇_÷Z+2߄&[
+Tr^藺97~c܎=[f1RrBǓ^kEMhxYVm<[џ6|	kqbѱ|
YA{G8p?\UM7Z66	g1U1igU69 u5Pƪ:VVZC=[@ҹ¨$kSmɳО\vFz~i3^aOsŧυ9Q}_3	όO{/wgoet39vO2ea;Ύ7$U#?k+Ek&dpzbӱ+TaB0gN{[N7Gי}U7&@?>Fz~E!a@s
?'67XxO*!?qi]֏TQN@tI+\^s8l0)2k!!iW8F$(yOּT.k,/#1:}8uT˾+5=O/`IWG֯b.-<= HOm;~so~hW5+kS8s.zwE|
?4ӿw/KN9?j(#0UT`Wzw}:_*9m>󑓀F?ELzv=8q:=WgJ`nDr	Zе<ֹ](Q@Q@Q@Q@Q@Q@Q@Q@'IdC0EYJVcMty_~u+Sw-aO
n<[YJgL#6i
g5ЖDZ14cʝ!!\/M}/_AYR__>oC?_?7_G#RERW쏞KB}JxGSkǕApƱơPm]hwB7U$Zq
M95"3q1ioATߚ{g.t
uu2k=;h#YB=fgS	:TdLԃ!44mFK{Hrd^7oz|BVr<{)6AXգV»|>*/hS܏z͆OM=Εq
(s|s׊LKQI :9NJ)P+!ʣoAF>+=@I}"x/}۠1aנc¹4emC:>p_xWKX`>R3_S½èųp3޺u3Ne
یbmͺ<_mnݮ1Op?Gm)Qb%N585'%Ahs\6yw!"&Ɨ._wk)}GP;Z!#\"<
*oƾ\)}N>"լ/~]Lg}pBG X?<zZ#x69S=6)jzx=y9O&>+e!!??s~k5Gʏ)?*ce7Ox~k5􇔾Q/e7/Ԑ#3OgNC0]
;_FiRl>Q.g>!%k#ú:Kn'&}?U@\pџPtp)v<{_i}Oվֲ3XIYIx~b<D?(=_JXH=bbi=Oh?_C_O)}oW쏜?
%Ƶ;-RYFi`wۭ{ϖZMtQ$"c_+ԃx1*0b;ԕ݋ESQEQEQEQEQEQEQEQEQEQZ(1F)h1K@XLRE&9P
(bf{RӨ&)PEPEPbԴPGKZ(iإbn(:A%S0(-&)P+	ڎԴP11F)h&:LRmQ@Q@Š(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((PKje88PK&AOEBPS/dcommon/help.gif!GIF89a1εֵ֜֜{kZsBc{,@	)sƠTQ$8(4ʔ%ŌCK$A HP`$h8ŒSd+ɡ\
H@%'6M
HO3SJM	/:Zi[7	\(	
R9r
ERI%	N=aq
 qƦs	*q-n/Sqj	
D XZ;PKއ{&!PK&AOEBPS/search.htm 

Using Oracle Text Name Search



9 Using Oracle Text Name Search


This chapter describes how to use the name search facility, and includes:






9.1 Overview of Name Search


Someone accustomed to the spelling rules of one culture can have difficulty applying those same rules to a name originating from a different culture. Name searching (also called name matching) provides a solution to match proper names that might differ in spelling due to orthographic variation. It also enables you to search for somewhat inaccurate data, such as might occur when a record's first name and surname are not properly segmented. This ability to handle somewhat inaccurate data is the main advantage of name searching.








9.2 Examples of Using Name Search


The following example illustrates how to use NDATA sections to search on names:


drop table people;
 
create table people (
  full_name varchar2(2000)
);
 
insert into people values
('John Black Smith');
 
-- multi_column datastore is a convenient way of adding section tags around our data
exec ctx_ddl.drop_preference('name_ds')
begin
  ctx_ddl.create_preference('name_ds', 'MULTI_COLUMN_DATASTORE');
  ctx_ddl.set_attribute('name_ds', 'COLUMNS', 'full_name');
end;
/
 
exec ctx_ddl.drop_section_group('name_sg');
begin
  ctx_ddl.create_section_group('name_sg', 'BASIC_SECTION_GROUP');
  ctx_ddl.add_ndata_section('name_sg', 'full_name', 'full_name');
end;
/
-- You can optionally load a thesaurus of nicknames
-- HOST ctxload -thes -name nicknames -file nicknames.txt
 
exec ctx_ddl.drop_preference('name_wl');
begin
  ctx_ddl.create_preference('name_wl', 'BASIC_WORDLIST');
  ctx_ddl.set_attribute('name_wl', 'NDATA_ALTERNATE_SPELLING', 'FALSE');
  ctx_ddl.set_attribute('name_wl', 'NDATA_BASE_LETTER', 'TRUE');
  -- Include the following line only if you have loaded the thesaurus
  -- file nicknames.txt:
  -- ctx_ddl.set_attribute('name_wl', 'NDATA_THESAURUS', 'nicknames');
  ctx_ddl.set_attribute('name_wl', 'NDATA_JOIN_PARTICLES',
   'de:di:la:da:el:del:qi:abd:los:la:dos:do:an:li:yi:yu:van:jon:un:sai:ben:al');
end;
/
 
create index people_idx on people(full_name) indextype is ctxsys.context
  parameters ('datastore name_ds section group name_sg wordlist name_wl');
 
-- Now you can do name searches with the following SQL:
 
var name varchar2(80);
exec :name := 'Jon Blacksmith'
 
select /*+ FIRST_ROWS */ full_name, score(1)
  from people
  where contains(full_name,  'ndata( full_name, '||:name||') ',1)>0
  order by score(1) desc
/



The following example illustrates a more complicated version of using NDATA sections to search on names:


create table emp (
    first_name    varchar2(30),
    middle_name   varchar2(30),
    last_name     varchar2(30),
    email         varchar2(30),
    phone         varchar2(30));

insert into emp values
('John', 'Black', 'Smith', 'john.smith@example.org', '123-456-7890');

-- user datastore procedure
create or replace procedure empuds_proc
   (rid in rowid, tlob in out nocopy clob) is
     tag varchar2(30);
     phone varchar2(30);
begin
  for c1 in (select FIRST_NAME, MIDDLE_NAME, LAST_NAME, EMAIL, PHONE
             from emp
             where rowid = rid)
  loop
     tag :='<email>';
     dbms_lob.writeappend(tlob, length(tag), tag);
     if (c1.EMAIL is not null) then
         dbms_lob.writeappend(tlob, length(c1.EMAIL), c1.EMAIL);
     end if;
     tag :='</email>';
     dbms_lob.writeappend(tlob, length(tag), tag);
     tag :='<phone>';
     dbms_lob.writeappend(tlob, length(tag), tag);
     if (c1.PHONE is not null) then
       phone := nvl(REGEXP_SUBSTR(c1.PHONE, '\d\d\d\d($|\s)'), ' ');
       dbms_lob.writeappend(tlob, length(phone), phone);
     end if;
     tag :='</phone>';
     dbms_lob.writeappend(tlob, length(tag), tag);
     tag :='<fullname>';
     dbms_lob.writeappend(tlob, length(tag), tag);
     if (c1.FIRST_NAME is not null) then
       dbms_lob.writeappend(tlob, length(c1.FIRST_NAME), c1.FIRST_NAME);
       dbms_lob.writeappend(tlob, length(' '), ' ');
     end if;
     if (c1.MIDDLE_NAME is not null) then
       dbms_lob.writeappend(tlob, length(c1.MIDDLE_NAME), c1.MIDDLE_NAME);
       dbms_lob.writeappend(tlob, length(' '), ' ');
     end if;
     if (c1.LAST_NAME is not null) then
       dbms_lob.writeappend(tlob, length(c1.LAST_NAME), c1.LAST_NAME);
     end if;
     tag :='</fullname>';
     dbms_lob.writeappend(tlob, length(tag), tag);
   end loop;
  end;
  /

--list
show errors
 
exec ctx_ddl.drop_preference('empuds');
begin
  ctx_ddl.create_preference('empuds', 'user_datastore');
  ctx_ddl.set_attribute('empuds', 'procedure', 'empuds_proc');
  ctx_ddl.set_attribute('empuds', 'output_type', 'CLOB');
end;
/
 
exec ctx_ddl.drop_section_group('namegroup');
begin
  ctx_ddl.create_section_group('namegroup', 'BASIC_SECTION_GROUP');
  ctx_ddl.add_ndata_section('namegroup', 'fullname', 'fullname');
  ctx_ddl.add_ndata_section('namegroup', 'phone', 'phone');
  ctx_ddl.add_ndata_section('namegroup', 'email', 'email');
end;
/
 
-- Need to load nicknames thesaurus
-- ctxload -thes -name nicknames -file dr0thsnames.txt
-- You can find sample nicknames thesaurus file, dr0thsnames.txt, under
-- $ORACLE_HOME/ctx/sample/thes directory.

exec ctx_ddl.drop_preference('ndata_wl');
begin
   ctx_ddl.create_preference('NDATA_WL', 'BASIC_WORDLIST');
   ctx_ddl.set_attribute('NDATA_WL', 'NDATA_ALTERNATE_SPELLING', 'FALSE');
   ctx_ddl.set_attribute('NDATA_WL', 'NDATA_BASE_LETTER', 'TRUE');
   ctx_ddl.set_attribute('NDATA_WL', 'NDATA_THESAURUS', 'NICKNAMES');
   ctx_ddl.set_attribute('NDATA_WL', 'NDATA_JOIN_PARTICLES',
    'de:di:la:da:el:del:qi:abd:los:la:dos:do:an:li:yi:yu:van:jon:un:sai:ben:al');
end;
/
 
exec ctx_output.start_log('emp_log');
create index name_idx on emp(first_name) indextype is ctxsys.context
parameters ('datastore empuds section group namegroup wordlist ndata_wl
  memory 500M');
 
exec ctx_output.end_log; 
 
-- Now you can do name searches with the following SQL:
var name varchar2(80);
exec :name := 'Jon Blacksmith'

select first_name, middle_name, last_name, phone, email, scr from
   (select /*+ FIRST_ROWS */
          first_name, middle_name, last_name, phone, email, score(1) scr
    from emp
    where contains(first_name,
          'ndata(phone, '||:name||') OR  ndata(email,'||:name||') OR
           ndata(fullname, '||:name||') ',1)>0
    order by score(1) desc
   ) where rownum <= 10;







PK	  PK&A
OEBPS/toc.htm

Table of Contents



Contents


List of Tables


Title and Copyright Information


Preface



1 Understanding Oracle Text Application Development



2 Getting Started with Oracle Text



3 Indexing with Oracle Text



4 Querying with Oracle Text



5 Presenting Documents in Oracle Text



6 Classifying Documents in Oracle Text



7 Tuning Oracle Text



8 Searching Document Sections in Oracle Text



9 Using Oracle Text Name Search



10 Working With a Thesaurus in Oracle Text



11 Using XML Query Result Set Interface



12 Administering Oracle Text



13 Migrating Oracle Text Applications



A CONTEXT Query Application



B CATSEARCH Query Application



Glossary


Index






PKK*ϱPK&AOEBPS/view.htmg

Presenting Documents in Oracle Text



5 Presenting Documents in Oracle Text


This chapter describes document presentation. The following topics are covered:






5.1 Highlighting Query Terms


In Oracle Text query applications, you can present selected documents with query terms highlighted for text queries or with themes highlighted for ABOUT queries.


You can generate three types of output associated with highlighting:


  • 

    A marked-up version of the document
    

  • 

    Query offset information for the document
    

  • 

    A concordance of the document, in which occurrences of the query term are returned with their surrounding text
    






5.1.1 Text highlighting


For text highlighting, you supply the query, and Oracle Text highlights words in document that satisfy the query. You can obtain plain-text or HTML highlighting.








5.1.2 Theme Highlighting


For ABOUT queries, the CTX_DOC procedures highlight and mark up words or phrases that best represent the ABOUT query.








5.1.3 CTX_DOC Highlighting Procedures


These are the highlighting procedures in CTX_DOC:


  • 

    CTX_DOC.MARKUP and CTX_DOC.POLICY_MARKUP
    

  • 

    CTX_DOC.HIGHLIGHT and CTX_DOC.POLICY_HIGHLIGHT
    

  • 

    CTX_DOC.SNIPPET and CTX_DOC.POLICY_SNIPPET
    



The POLICY and non-POLICY versions of the procedures are equivalent, except that the POLICY versions do not require an index.





5.1.3.1 Markup Procedure


The CTX_DOC.MARKUP and CTX_DOC.POLICY_MARKUP procedures take a document reference and a query, and return a marked-up version of the document. The output can be either marked-up plaintext or marked-up HTML. For example, you might specify that a marked-up document be returned with the query term surrounded by angle brackets (<<<tansu>>>) or HTML (<b>tansu</b>).


CTX_DOC.MARKUP and CTX_DOC.POLICY_MARKUP are equivalent, except that CTX_DOC.POLICY_MARKUP does not require an index.


You can customize the markup sequence for HTML navigation.





5.1.3.1.1 CTX_DOC.MARKUP Example



The following example is taken from the Web application described in Appendix A, "CONTEXT Query Application". The procedure showDoc takes an HTML document and a query, creates the highlight markup—in this case, the query term will display in red—and outputs the result to an in-memory buffer. It then uses htp.print to display it in the browser.


procedure showDoc (p_id in varchar2, p_query in varchar2) is

 v_clob_selected   CLOB;
 v_read_amount     integer;
 v_read_offset     integer;
 v_buffer          varchar2(32767);
 v_query           varchar(2000);
 v_cursor          integer;

 begin
   htp.p('<html><title>HTML version with highlighted terms</title>');
   htp.p('<body bgcolor="#ffffff">');
   htp.p('<b>HTML version with highlighted terms</b>');

   begin
     ctx_doc.markup (index_name => 'idx_search_table',
                     textkey    => p_id,
                     text_query => p_query,
                     restab     => v_clob_selected,
                     starttag   => '<i><font color=red>',
                     endtag     => '</font></i>');

     v_read_amount := 32767;
     v_read_offset := 1;
     begin
      loop
        dbms_lob.read(v_clob_selected,v_read_amount,v_read_offset,v_buffer);
        htp.print(v_buffer);
        v_read_offset := v_read_offset + v_read_amount;
        v_read_amount := 32767;
      end loop;
     exception
      when no_data_found then
         null;
     end;

     exception
      when others then
        null; --showHTMLdoc(p_id);
   end;
end showDoc;
end;
/
show errors
set define on










See Also:

Oracle Text Reference for more information about CTX_DOC.MARKUP and CTX_DOC.POLICY_SNIPPET














5.1.3.2 Highlight Procedure


CTX_DOC.HIGHLIGHT and CTX_DOC.POLICY_HIGHLIGHT take a query and a document and return offset information for the query in either plaintext or HTML formats. This offset information can be used to write your own custom routines for displaying documents.


CTX_DOC.HIGHLIGHT and CTX_DOC.POLICY_HIGHLIGHT are equivalent, except that CTX_DOC.POLICY_HIGHLIGHT does not require an index.


With offset information, you can display a highlighted version of document as desired. For example, you can display the document with different font types or colors rather than using the standard plain text markup obtained from CTX_DOC.MARKUP.









See Also:

Oracle Text Reference for more information about using CTX_DOC.HIGHLIGHT and CTX_DOC.POLICY_HIGHLIGHT












5.1.3.3 Concordance


CTX_DOC.SNIPPET and CTX_DOC.POLICY_SNIPPET produce a concordance of the document, in which occurrences of the query term are returned with their surrounding text. This result is sometimes known as Key Word in Context, or KWIC, because instead of returning the entire document (with or without the query term highlighted), it returns the query term in text fragments, allowing a user to see it in context. You can control the way the query term is highlighted in the returned fragments.


CTX_DOC.SNIPPET and CTX_DOC.POLICY_SNIPPET are equivalent, except that CTX_DOC.POLICY_SNIPPET does not require an index.









See Also:

Oracle Text Reference for more information about CTX_DOC.SNIPPET and CTX_DOC.POLICY_SNIPPET
















5.2 Obtaining Lists of Themes, Gists, and Theme Summaries


The following table describes lists of themes, gists, and theme summaries.




Table 5-1 Lists of Themes, Gists, and Theme Summaries


Output TypeDescription


List of Themes



A list of the main concepts of a document.


You can generate list of themes where each theme is a single word or phrase or where each theme is a hierarchical list of parent themes.




Gist



Text in a document that best represents what the document is about as a whole.




Theme Summary



Text in a document that best represents a given theme in the document.







To obtain this output, you use procedures in the CTX_DOC supplied package. With this package, you can do the following:


  • 

    Identify documents by ROWID in addition to primary key
    

  • 

    Store results in-memory for improved performance
    






5.2.1 Lists of Themes


A list of themes is a list of the main concepts in a document. Use the CTX_DOC.THEMES procedure to generate lists of themes.









See Also:

Oracle Text Reference to learn more about the command syntax for CTX_DOC.THEMES









5.2.1.1 In-Memory Themes


The following example generates the top 10 themes for document 1 and stores them in an in-memory table called the_themes. The example then loops through the table to display the document themes.


declare
 the_themes ctx_doc.theme_tab;

begin
 ctx_doc.themes('myindex','1',the_themes, numthemes=>10);
 for i in 1..the_themes.count loop
  dbms_output.put_line(the_themes(i).theme||':'||the_themes(i).weight);
  end loop;
end;







5.2.1.2 Result Table Themes


To create a theme table:


create table ctx_themes (query_id number, 
                         theme varchar2(2000), 
                         weight number);






5.2.1.2.1 Single Themes


To obtain a list of themes where each element in the list is a single theme, enter the following:


begin
ctx_doc.themes('newsindex','34','CTX_THEMES',1,full_themes => FALSE);
end;







5.2.1.2.2 Full Themes


To obtain a list of themes where each element in the list is a hierarchical list of parent themes, enter the following:


begin
ctx_doc.themes('newsindex','34','CTX_THEMES',1,full_themes => TRUE);
end;











5.2.2 Gist and Theme Summary


A gist is the text of a document that best represents what the document is about as a whole. A theme summary is the text of a document that best represents a single theme in the document.


Use the procedure CTX_DOC.GIST to generate gists and theme summaries. You can specify the size of the gist or theme summary when you call the procedure.









See Also:

Oracle Text Reference to learn about the command syntax for CTX_DOC.GIST









5.2.2.1 In-Memory Gist


The following example generates a nondefault size generic gist of at most 10 paragraphs. The result is stored in memory in a CLOB locator. The code then de-allocates the returned CLOB locator after using it.


declare
  gklob clob;
  amt number := 40;
  line varchar2(80);

begin
 ctx_doc.gist('newsindex','34','gklob',1,glevel => 'P',pov => 'GENERIC',       numParagraphs => 10);
  -- gklob is NULL when passed-in, so ctx-doc.gist will allocate a temporary
  -- CLOB for us and place the results there.
  
  dbms_lob.read(gklob, amt, 1, line);
  dbms_output.put_line('FIRST 40 CHARS ARE:'||line);
  -- have to de-allocate the temp lob
  dbms_lob.freetemporary(gklob);
 end;







5.2.2.2 Result Table Gists


To create a gist table:


create table ctx_gist (query_id  number,
                       pov       varchar2(80), 
                       gist      CLOB);



The following example returns a default sized paragraph level gist for document 34:


begin
ctx_doc.gist('newsindex','34','CTX_GIST',1,'PARAGRAPH', pov =>'GENERIC');
end;



The following example generates a nondefault size gist of ten paragraphs:


begin
ctx_doc.gist('newsindex','34','CTX_GIST',1,'PARAGRAPH', pov =>'GENERIC',        numParagraphs => 10);
end;



The following example generates a gist whose number of paragraphs is ten percent of the total paragraphs in document:


begin 
ctx_doc.gist('newsindex','34','CTX_GIST',1, 'PARAGRAPH', pov =>'GENERIC', maxPercent => 10);
end;







5.2.2.3 Theme Summary


The following example returns a theme summary on the theme of insects for document with textkey 34. The default Gist size is returned.


begin
ctx_doc.gist('newsindex','34','CTX_GIST',1, 'PARAGRAPH', pov => 'insects');
end;











5.3 Document Presentation and Highlighting


Typically, a query application enables the user to view the documents returned by a query. The user selects a document from the hit list and then the application presents the document in some form.


With Oracle Text, you can display a document in different ways. For example, you can present documents with query terms highlighted. Highlighted query terms can be either the words of a word query or the themes of an ABOUT query in English.


You can also obtain gist (document summary) and theme information from documents with the CTX_DOC PL/SQL package.


Table 5-2 describes the different output you can obtain and which procedure to use to obtain each type.




Table 5-2 CTX_DOC Output


OutputProcedure


Plain text version, no highlights



CTX_DOC.FILTER




HTML version of document, no highlights



CTX_DOC.FILTER




Highlighted document, plain text version



CTX_DOC.MARKUP




Highlighted document, HTML version



CTX_DOC.MARKUP




Highlight offset information for plain text version



CTX_DOC.HIGHLIGHT




Highlight offset information for HTML version



CTX_DOC.HIGHLIGHT




Theme summaries and gist of document.



CTX_DOC.GIST




List of themes in document.



CTX_DOC.THEMES








Figure 5-1 shows an original document to which we can apply highlighting, gisting, and theme extraction in the following sections.




Figure 5-1 Sample Document for Highlighting, Gisting, and Theme Extraction

Description of Figure 5-1 follows

Description of "Figure 5-1 Sample Document for Highlighting, Gisting, and Theme Extraction"








5.3.1 Highlighting Example


Figure 5-2 is a screen shot of a query application presenting the document shown in Figure 5-1 with the query term pet highlighted. This output was created using the text query application produced by a wizard described in Appendix A, "CONTEXT Query Application".




Figure 5-2 Pet Highlighted in Pet Magnet Document

Description of Figure 5-2 follows

Description of "Figure 5-2 Pet Highlighted in Pet Magnet Document"










5.3.2 Document List of Themes Example


Figure 5-3 is a screen shot of a query application presenting a list of themes for the document shown in Figure 5-1. This output was created using the text query application produced by a wizard described in Appendix A, "CONTEXT Query Application".




Figure 5-3 Query Application Displaying Document Themes

Description of Figure 5-3 follows

Description of "Figure 5-3 Query Application Displaying Document Themes"










5.3.3 Gist Example


Figure 5-4 is a screen shot of a query application presenting a gist of the document shown in Figure 5-1. This output was created using the text query application produced by a wizard described in Appendix A, "CONTEXT Query Application".




Figure 5-4 Query Application Presenting Document Gist

Description of Figure 5-4 follows

Description of "Figure 5-4 Query Application Presenting Document Gist"












PKhgPK&A
OEBPS/ind.htm

Indexing with Oracle Text



3 Indexing with Oracle Text


This chapter provides an introduction to Oracle Text indexing. The following topics are discussed:






3.1 About Oracle Text Indexes


This section discusses the different types of Oracle Text indexes, their structure, the indexing process, and limitations. The following subjects are included:






3.1.1 Types of Oracle Text Indexes


With Oracle Text, you can create indexes of several types, using CREATE INDEX. Table 3-1 describes each index type, its purpose, and the features it supports.




Table 3-1 Oracle Text Index Types


Index TypeDescriptionSupported Preferences and ParametersQuery OperatorNotes


CONTEXT



Use this index to build a text retrieval application when your text consists of large coherent documents. You can index documents of different formats such as MS Word, HTML or plain text.


You can customize the index in a variety of ways.


This index type requires CTX_DDL.SYNC_INDEX after DML on base table.



All CREATE INDEX preferences and parameters supported except for INDEX SET.


These supported parameters include the index partition clause, and the format, charset, and language columns.



CONTAINS


Grammar is called the CONTEXT grammar, which supports a rich set of operations.


The CTXCAT grammar can be used with query templating.



Supports all documents services and query services.


Supports indexing of partitioned text tables.


Supports FILTER BY and ORDER BY clauses of CREATE INDEX to also index structured column values for more efficient processing of mixed queries.




CTXCAT



Use this index type for better mixed query performance. Typically, with this index type, you index small documents or text fragments. Other columns in the base table, such as item names, prices, and descriptions can be included in the index to improve mixed query performance.


This index type is transactional, automatically updating itself after DML to base table. No CTX_DDL.SYNC_INDEX is necessary.



INDEX SET


LEXER


STOPLIST


STORAGE


WORDLIST (only prefix_index attribute supported for Japanese data)


Format, charset, and language columns not supported.


Table and index partitioning not supported.



CATSEARCH


Grammar is called CTXCAT, which supports logical operations, phrase queries, and wildcarding.


The CONTEXT grammar can be used with query templating.


Theme querying is supported.



This index is larger and takes longer to build than a CONTEXT index.


The size of a CTXCAT index is related to the total amount of text to be indexed, the number of indexes in the index set, and the number of columns indexed. Carefully consider your queries and your resources before adding indexes to the index set.


The CTXCAT index does not support table and index partitioning, documents services (highlighting, markup, themes, and gists) or query services (explain, query feedback, and browse words.)




CTXRULE



Use CTXRULE index to build a document classification or routing application. This index is created on a table of queries, where the queries define the classification or routing criteria.



See "CTXRULE Parameters and Limitations".



MATCHES



Single documents (plain text, HTML, or XML) can be classified using the MATCHES operator, which turns a document into a set of queries and finds the matching rows in the CTXRULE index.




CTXXPATH



Create this index when you need to speed up existsNode() queries on an XMLType column.



STORAGE



Use with existsNode()



This indextype is deprecated and is only supported for backward compatibility with older releases of Oracle Database where XMLIndex is not available. If you are building a new application, Oracle recommends that you use XMLIndex.


Can only create this index on XMLType column.


Although this index type can be helpful for existsNode() queries, it is not required for XML searching. See "XML Search Applications".








An Oracle Text index is an Oracle Database domain index. To build your query application, you can create an index of type CONTEXT with a mixture of text and structured data columns, and query it with the CONTAINS operator.


You create an index from a populated text table. In a query application, the table must contain the text or pointers to where the text is stored. Text is usually a collection of documents, but can also be small text fragments.


For better performance for mixed queries, you can create a CONTEXT index with FILTER BY and/or ORDER BY clauses to specify relational columns that will be used in structured criteria of the mixed query. Query this index with the CONTAINS operator.


Use the CTXCAT index type when your application relies heavily on mixed queries to search small documents or descriptive text fragments based on related criteria such as dates or prices. Query this index with the CATSEARCH operator.


To build a document classification application using simple or rule-based classification, create an index of type CTXRULE. This index classifies plain text, HTML, or XML documents using the MATCHES operator. Store your defining query set in the text table you index.


If you are working with XMLtype columns, then create an XMLIndex index to speed up queries with existsNode.









Note:

The CTXXPATH index type is deprecated. It is only supported for backward compatibility with older releases of Oracle Database where XMLIndex is not available. If you are building a new application, then Oracle recommends that you use XMLIndex.






Create a text index as a type of extensible index to Oracle Database using standard SQL. This means that an Oracle Text index operates like an Oracle Database index. It has a name by which it is referenced and can be manipulated with standard SQL statements.


The benefits of a creating an Oracle Text index include fast response time for text queries with the CONTAINS, CATSEARCH, and MATCHES Oracle Text operators. These operators query the CONTEXT, CTXCAT, and CTXRULE index types respectively.









Note:

Because a transparent data encryption-enabled column does not support domain indexes, it cannot be used with Oracle Text. However, you can create an Oracle Text index on a column in a table stored in TDE-enabled tablespace.













3.1.2 Structure of the Oracle Text CONTEXT Index


Oracle Text indexes text by converting all words into tokens. The general structure of an Oracle Text CONTEXT index is an inverted index where each token contains the list of documents (rows) that contain that token.


For example, after a single initial indexing operation, the word DOG might have an entry as follows:




WordAppears in Document
DOGDOC1 DOC3 DOC5





This means that the word DOG is contained in the rows that store documents one, three, and five.





3.1.2.1 Merged Word and Theme Index


By default in English and French, Oracle Text indexes theme information with word information. You can query theme information with the ABOUT operator. You can optionally enable and disable theme indexing.









See Also:

"Creating Preferences" to learn more about indexing theme information














3.1.3 The Oracle Text Indexing Process


This section describes the Oracle Text indexing process. Initiate the indexing process with the CREATE INDEX statement. Initiate the indexing process using the CREATE INDEX statement to create an Oracle Text index of tokens, organized according to the parameters and preferences you specify.


Figure 3-1 shows the indexing process. This process is a data stream that is acted upon by the different indexing objects. Each object corresponds to an indexing preference type or section group you can specify in the parameter string of CREATE INDEX or ALTER INDEX. The following sections describe these objects.




Figure 3-1 Oracle Text Indexing Process

Description of Figure 3-1 follows

Description of "Figure 3-1 Oracle Text Indexing Process"








3.1.3.1 Datastore Object


The stream starts with the datastore reading in the documents as they are stored in the system according to your datastore preference. For example, if you have defined your datastore as FILE_DATASTORE, then the stream starts by reading the files from the operating system. You can also store your documents on the Internet or in Oracle Database. Wherever your files reside physically, you must always have a text table in Oracle Database that points to the file.








3.1.3.2 Filter Object


The stream then passes through the filter. What happens here is determined by your FILTER preference. The stream can be acted upon in one of the following ways:


  • 

    No filtering takes place. This happens when you specify the NULL_FILTER preference type or when the value of the format column is IGNORE. Documents that are plain text, HTML, or XML need no filtering.
    

  • 

    Formatted documents (binary) are filtered to marked-up text. This happens when you specify the AUTO_FILTER preference type or when the value of the format column is BINARY.
    

  • 

    Text is converted from a non-database character set to the database character set. This happens when you specify CHARSET_FILTER preference type.
    









3.1.3.3 Sectioner Object


After being filtered, the marked-up text passes through the sectioner that separates the stream into text and section information. Section information includes where sections begin and end in the text stream. The type of sections extracted is determined by your section group type.


The section information is passed directly to the indexing engine which uses it later. The text is passed to the lexer.








3.1.3.4 Lexer Object


You create a lexer preference using one of the Oracle Text lexer types to specify the language of the text to be indexed. The lexer breaks the text into tokens according to your language. These tokens are usually words. To extract tokens, the lexer uses the parameters as defined in your lexer preference. These parameters include the definitions for the characters that separate tokens such as whitespace, and whether to convert the text to all uppercase or to leave it in mixed case.


When theme indexing is enabled, the lexer analyzes your text to create theme tokens for indexing.








3.1.3.5 Indexing Engine


The indexing engine creates the inverted index that maps tokens to the documents that contain them. In this phase, Oracle Text uses the stoplist you specify to exclude stopwords or stopthemes from the index. Oracle Text also uses the parameters defined in your WORDLIST preference, which tell the system how to create a prefix index or substring index, if enabled.










3.1.4 Partitioned Tables and Indexes


You can create a partitioned CONTEXT index on a partitioned text table. The table must be partitioned by range. Hash, composite, and list partitions are not supported.


You might create a partitioned text table to partition your data by date. For example, if your application maintains a large library of dated news articles, you can partition your information by month or year. Partitioning simplifies the manageability of large databases, because querying, DML, and backup and recovery can act on a single partition.


On local CONTEXT indexes with multiple table sets, Oracle Text supports the number of partitions supported by Oracle Database.









Note:

The number of partitions supported in Oracle Text is approximately 1024K-1. This limit, which should be more than adequate, is not applicable to a CONTEXT index on partitioned tables.













See Also:

Oracle Database Concepts for more information about partitioning









3.1.4.1 Querying Partitioned Tables


To query a partitioned table, you use CONTAINS in the WHERE clause of a SELECT statement as you query a regular table. You can query the entire table or a single partition. However, if you are using the ORDER BY SCORE clause, Oracle recommends that you query single partitions unless you include a range predicate that limits the query to a single partition.










3.1.5 Creating an Index Online


When it is not practical to lock up your base table for indexing because of ongoing updates, you can create your index online with the ONLINE parameter of CREATE INDEX. This way an application with heavy DML need not stop updating the base table for indexing.


There are short periods, however, when the base table is locked at the beginning and end of the indexing process.









See Also:

Oracle Text Reference to learn more about creating an index online












3.1.6 Parallel Indexing


Oracle Text supports parallel indexing with CREATE INDEX.


When you enter a parallel indexing statement on a non-partitioned table, Oracle Text splits the base table into temporary partitions, spawns child processes, and assigns a child to a partition. Each child then indexes the rows in its partition. The method of slicing the base table into partitions is determined by Oracle and is not under your direct control. This is true as well for the number of child processes actually spawned, which depends on machine capabilities, system load, your init.ora settings, and other factors. Because of these variables, the actual parallel degree may not match the degree of parallelism requested.


Because indexing is an I/O intensive operation, parallel indexing is most effective in decreasing your indexing time when you have distributed disk access and multiple CPUs. Parallel indexing can only affect the performance of an initial index with CREATE INDEX. It does not affect DML performance with ALTER INDEX, and has minimal impact on query performance.


Because parallel indexing decreases the initial indexing time, it is useful for the following scenarios:









3.1.7 Indexing and Views


Oracle SQL standards do not support creating indexes on views. If you need to index documents whose contents are in different tables, you can create a data storage preference using the USER_DATASTORE object. With this object, you can define a procedure that synthesizes documents from different tables at index time.









See Also:

Oracle Text Reference to learn more about USER_DATASTORE






Oracle Text does support the creation of CONTEXT, CTXCAT, CTXRULE, and CTXXPATH indexes on materialized views (MVIEW).










3.2 Considerations For Indexing


Use the CREATE INDEX statement to create an Oracle Text index. When you create an index and specify no parameter string, an index is created with default parameters. You can create either a CONTEXT, CTXCAT, or CTXRULE index. This sections contains the following topics:



You can also override the defaults and customize your index to suit your query application. The parameters and preference types you use to customize your index with CREATE INDEX fall into the following general categories.





3.2.1 Location of Text


The basic prerequisite for an Oracle Text query application is to have a populated text table. The text table is where you store information about your document collection and is required for indexing.


When you create a CONTEXT index, you can populate rows in your text table with one of the following elements:


  • 

    Text information (can be documents or text fragments)
    

  • 

    Path names of documents in your file system
    

  • 

    URLs that specify World Wide Web documents
    



Figure 3-2 illustrates these different methods.


When creating a CTXCAT or CTXRULE index, only the first method shown is supported.




Figure 3-2 Different Ways of Storing Text

Description of Figure 3-2 follows

Description of "Figure 3-2 Different Ways of Storing Text"





By default, the indexing operation expects your document text to be directly loaded in your text table, which is the first method shown previously.


However, when you create a CONTEXT index, you can specify the other ways of identifying your documents such as with filenames or with URLs by using the corresponding data storage indexing preference.





3.2.1.1 Supported Column Types


With Oracle Text, you can create a CONTEXT index with columns of type VARCHAR2, CLOB, BLOB, CHAR, BFILE, XMLType, and URIType.









Note:

The column types NCLOB, DATE and NUMBER cannot be indexed.












3.2.1.2 Storing Text in the Text Table


This section discusses how you can store text in directly in your table with the different indexes.





3.2.1.2.1 CONTEXT Data Storage


You can store documents in your text table in different ways.


You can store documents in one column using the DIRECT_DATASTORE data storage type or over a number of columns using the MULTI_COLUMN_DATASTORE type. When your text is stored over a number of columns, Oracle Text concatenates the columns into a virtual document for indexing.


You can also create master-detail relationships for your documents, where one document can be stored across a number of rows. To create master-detail index, use the DETAIL_DATASTORE data storage type.


You can also store your text in a nested table using the NESTED_DATASTORE type.


Oracle Text supports the indexing of the XMLType datatype, which you use to store XML documents.








3.2.1.2.2 CTXCAT Data Storage


In your text table, you can also store short text fragments such as names, descriptions, and addresses over a number of columns and create a CTXCAT index. A CTXCAT index improves performance for mixed queries.










3.2.1.3 Storing File Path Names


In your text table, you can store path names to files stored in your file system. When you do so, use the FILE_DATASTORE preference type during indexing. This method of data storage is supported for CONTEXT indexes only.








3.2.1.4 Storing URLs


You can store URL names to index Web sites. When you do so, use the URL_DATASTORE preference type during indexing. This method of data storage is supported for CONTEXT indexes only.








3.2.1.5 Storing Associated Document Information


In your text table, you can create additional columns to store structured information that your query application might need, such as primary key, date, description, or author.








3.2.1.6 Format and Character Set Columns


If your documents are of mixed formats or of mixed character sets, you can create the following additional columns:


  • 

    A format column to record the format (TEXT or BINARY) to help filtering during indexing. You can also use the format column to ignore rows for indexing by setting the format column to IGNORE. This is useful for bypassing rows that contain data incompatible with text indexing such as images.
    

  • 

    A character set column to record the document character set for each row.
    



When you create your index, you must specify the name of the format or character set column in the parameter clause of CREATE INDEX.


For all rows containing the keywords AUTO or AUTOMATIC in character set or language columns, Oracle Text will apply statistical techniques to determine the character set and language respectively of the documents and modify document indexing appropriately.








3.2.1.7 Supported Document Formats


Because the system can index most document formats including HTML, PDF, Microsoft Word, and plain text, you can load any supported type into the text column.


When you have mixed formats in your text column, you can optionally include a format column to help filtering during indexing. With the format column you can specify whether a document is binary (formatted) or text (non-formatted such as HTML). If you mix HTML and XML documents in 1 index, you might not be able to configure your index to your needs; you cannot prevent stylesheet information from being added to the index.









See Also:

Oracle Text Reference for more information about the supported document formats












3.2.1.8 Summary of DATASTORE Types


When you index with CREATE INDEX, you specify the location using the datastore preference. Use the appropriate datastore according to your application.


Table 3-2 summarizes the different ways you can store your text with the datastore preference type.




Table 3-2 Summary of DATASTORE Types


Datastore TypeUse When


DIRECT_DATASTORE



Data is stored internally in a text column. Each row is indexed as a single document.


Your text column can be VARCHAR2, CLOB, BLOB, CHAR, or BFILE. XMLType columns are supported for the context index type.




MULTI_COLUMN_DATASTORE



Data is stored in a text table in more than one column. Columns are concatenated to create a virtual document, one document for each row.




DETAIL_DATASTORE



Data is stored internally in a text column. Document consists of one or more rows stored in a text column in a detail table, with header information stored in a master table.




FILE_DATASTORE



Data is stored externally in operating system files. Filenames are stored in the text column, one for each row.




NESTED_DATASTORE



Data is stored in a nested table.




URL_DATASTORE



Data is stored externally in files located on an intranet or the Internet. URLs are stored in the text column.




USER_DATASTORE



Documents are synthesized at index time by a user-defined stored procedure.







Indexing time and document retrieval time will be increased for indexing URLs, because the system must retrieve the document from the network.











3.2.2 Document Formats and Filtering


Formatted documents such as Microsoft Word and PDF must be filtered to text to be indexed. The type of filtering the system uses is determined by the FILTER preference type. By default, the system uses the AUTO_FILTER filter type, which automatically detects the format of your documents and filters them to text.


Oracle Text can index most formats. Oracle Text can also index columns that contain documents with mixed formats.





3.2.2.1 No Filtering for HTML


If you are indexing HTML or plain text files, do not use the AUTO_FILTER type. For best results, use the NULL_FILTER preference type.









3.2.2.2 Filtering Mixed-Format Columns


If you have a mixed-format column such as one that contains Microsoft Word, plain text, and HTML documents, you can bypass filtering for plain text or HTML by including a format column in your text table. In the format column, you tag each row TEXT or BINARY. Rows that are tagged TEXT are not filtered.


For example, you can tag the HTML and plain text rows as TEXT and the Microsoft Word rows as BINARY. You specify the format column in the CREATE INDEX parameter clause.


A third format column type, IGNORE, is provided for when you do not want a document to be indexed at all. This is useful, for example, when you have a mixed-format table that includes plain-text documents in both Japanese and English, but you only want to process the English documents; another example might be that of a mixed-format table that includes both plain-text documents and images. Because IGNORE is implemented at the datastore level, it can be used with all filters.








3.2.2.3 Custom Filtering


You can create your own custom filter to filter documents for indexing. You can create either an external filter that is executed from the file system or an internal filter as a PL/SQL or Java stored procedure.


For external custom filtering, use the USER_FILTER filter preference type.


For internal filtering, use the PROCEDURE_FILTER filter type.











3.2.3 Bypassing Rows for Indexing


You can bypass rows in your text table that are not to be indexed, such as rows that contain image data. To do so, create a format column in your table and set it to IGNORE. You name the format column in the parameter clause of CREATE INDEX.








3.2.4 Document Character Set


The indexing engine expects filtered text to be in the database character set. When you use the AUTO_FILTER filter type, formatted documents are converted to text in the database character set.


If your source is text and your document character set is not the database character set, then you can use the AUTO_FILTER or CHARSET_FILTER filter type to convert your text for indexing.





3.2.4.1 Character Set Detection


When the CHARSET column is set to AUTO, the AUTO_FILTER filter detects the character set of the document and converts it from the detected character set to the database character set, if there is a difference.








3.2.4.2 Mixed Character Set Columns


If your document set contains documents with different character sets, such as JA16EUC and JA16SJIS, you can index the documents provided you create a charset column. You populate this column with the name of the document character set for each row. You name the column in the parameter clause of the CREATE INDEX statement.










3.2.5 Document Language


Oracle Text can index most languages. By default, Oracle Text assumes the language of text to index is the language you specify in your database setup. Depending on the language of your documents, use one of the following lexer types:


Use the BASIC_LEXER preference type to index whitespace-delimited languages such as English, French, German, and Spanish. For some of these languages, you can enable alternate spelling, composite word indexing, and base letter conversion.


Use the MULTI_LEXER preference type for indexing tables containing documents of different languages such as English, German, and Japanese.


Use the USER_LEXER preference type to create your own lexer for indexing a particular language.


Use the WORLD_LEXER preference type for indexing tables containing documents of different languages and to autodetect the languages in the document.


You can also use other lexer types that are designed specifically to tokenize and index Japanese, Chinese, and Korean.









See Also:

Oracle Text Reference to learn more about indexing languages and lexer types









3.2.5.1 Language Features Outside BASIC_LEXER


With the BASIC_LEXER, Japanese, Chinese and Korean lexers, Oracle Text provides a lexing solution for most languages. For other languages, you can create your own lexing solution using the user-defined lexer interface. This interface enables you to create a PL/SQL or Java procedure to process your documents during indexing and querying.


You can also use the user-defined lexer to create your own theme lexing solution or linguistic processing engine.









See Also:

Oracle Text Reference to learn more about the user-defined lexer












3.2.5.2 Indexing Multi-language Columns


Oracle Text can index text columns that contain documents of different languages, such as a column that contains documents written in English, German, and Japanese. To index a multi-language column, you need a language column in your text table. Use the MULTI_LEXER preference type.


You can also incorporate a multi-language stoplist when you index multi-language columns.











3.2.6 Indexing Special Characters


When you use the BASIC_LEXER preference type, you can specify how non-alphanumeric characters such as hyphens and periods are indexed in relation to the tokens that contain them. For example, you can specify that Oracle Text include or exclude hyphen character (-) when indexing a word such as web-site.


These characters fall into BASIC_LEXER categories according to the behavior you require during indexing. The way you set the lexer to behave for indexing is the way it behaves for query parsing.


Some of the special characters you can set are as follows:






3.2.6.1 Printjoin Characters


Define a non-alphanumeric character as printjoin when you want this character to be included in the token during indexing.


For example, if you want your index to include hyphens and underscore characters, define them as printjoins. This means that words such as web-site are indexed as web-site. A query on website does not find web-site.









3.2.6.2 Skipjoin Characters


Define a non-alphanumeric character as a skipjoin when you do not want this character to be indexed with the token that contains it.


For example, with the hyphen (-) character defined as a skipjoin, the word web-site is indexed as website. A query on web-site finds documents containing website and web-site.








3.2.6.3 Other Characters


Other characters can be specified to control other tokenization behavior such as token separation (startjoins, endjoins, whitespace), punctuation identification (punctuations), number tokenization (numjoins), and word continuation after line-breaks (continuation). These categories of characters have defaults, which you can modify.









See Also:

Oracle Text Reference to learn more about the BASIC_LEXER














3.2.7 Case-Sensitive Indexing and Querying


By default, all text tokens are converted to uppercase and then indexed. This results in case-insensitive queries. For example, separate queries on each of the three words cat, CAT, and Cat all return the same documents.


You can change the default and have the index record tokens as they appear in the text. When you create a case-sensitive index, you must specify your queries with exact case to match documents. For example, if a document contains Cat, you must specify your query as Cat to match this document. Specifying cat or CAT does not return the document.


To enable or disable case-sensitive indexing, use the mixed_case attribute of the BASIC_LEXER preference.









See Also:

Oracle Text Reference to learn more about the BASIC_LEXER












3.2.8 Language-Specific Features


You can enable the following language-specific features at index time:






3.2.8.1 Indexing Themes


For English and French, you can index document theme information. A document theme is a concept that is sufficiently developed in the document. Themes can be queried with the ABOUT operator.


You can index theme information in other languages provided you have loaded and compiled a knowledge base for the language.


By default themes are indexed in English and French. You can enable and disable theme indexing with the index_themes attribute of the BASIC_LEXER preference type.









See Also:















3.2.8.2 Base-Letter Conversion for Characters with Diacritical Marks


Some languages contain characters with diacritical marks such as tildes, umlauts, and accents. When your indexing operation converts words containing diacritical marks to their base letter form, queries need not contain diacritical marks to score matches. For example in Spanish with a base-letter index, a query of energía matches energía and energia in the index.


However, with base-letter indexing disabled, a query of energía matches only energía.


You can enable and disable base-letter indexing for your language with the base_letter attribute of the BASIC_LEXER preference type.









See Also:

Oracle Text Reference to learn more about the BASIC_LEXER












3.2.8.3 Alternate Spelling


Languages such as German, Danish, and Swedish contain words that have more than one accepted spelling. For instance, in German, ae can be substituted for ä. The ae character pair is known as the alternate form.


By default, Oracle Text indexes words in their alternate forms for these languages. Query terms are also converted to their alternate forms. The result is that these words can be queried with either spelling.


You can enable and disable alternate spelling for your language using the alternate_spelling attribute in the BASIC_LEXER preference type.









See Also:

Oracle Text Reference to learn more about the BASIC_LEXER












3.2.8.4 Composite Words


German and Dutch text contain composite words. By default, Oracle Text creates composite indexes for these languages. The result is that a query on a term returns words that contain the term as a sub-composite.


For example, in German, a query on the term Bahnhof (train station) returns documents that contain Bahnhof or any word containing Bahnhof as a sub-composite, such as Hauptbahnhof, Nordbahnhof, or Ostbahnhof.


You can enable and disable the creation of composite indexes with the composite attribute of the BASIC_LEXER preference.









See Also:

Oracle Text Reference to learn more about the BASIC_LEXER












3.2.8.5 Korean, Japanese, and Chinese Indexing


Index these languages with specific lexers:




Table 3-3 Lexers for Asian Languages


LanguageLexer


Korean



KOREAN_MORPH_LEXER




Japanese



JAPANESE_LEXER, JAPANESE_VGRAM_LEXER




Chinese



CHINESE_LEXER,CHINESE_VGRAM_LEXER







These lexers have their own sets of attributes to control indexing.









See Also:

Oracle Text Reference to learn more about these lexers














3.2.9 Fuzzy Matching and Stemming


Fuzzy matching enables you to match similarly spelled words in queries.


Stemming enables you to match words with the same linguistic root. For example a query on $speak, expands to search for all documents that contain speak, speaks, spoke, and spoken.


Fuzzy matching and stemming are automatically enabled in your index if Oracle Text supports this feature for your language.


Fuzzy matching is enabled with default parameters for its similarity score lower limit and for its maximum number of expanded terms. At index time you can change these default parameters.


To improve the performance of stem queries, create a stem index by enabling the index_stems attribute of the BASIC_LEXER.









3.2.10 Better Wildcard Query Performance


Wildcard queries enable you to enter left-truncated, right-truncated and doubly truncated queries, such as %ing, cos%, or %benz%. With normal indexing, these queries can sometimes expand into large word lists, degrading your query performance.


Wildcard queries have better response time when token prefixes and substrings are recorded in the index.


By default, token prefixes and substrings are not recorded in the Oracle Text index. If your query application makes heavy use of wildcard queries, consider indexing token prefixes and substrings. To do so, use the wordlist preference type. The trade-off is a bigger index for improved wildcard searching.









3.2.11 Document Section Searching


For documents that have internal structure such as HTML and XML, you can define and index document sections. Indexing document sections enables you to narrow the scope of your queries to within pre-defined sections. For example, you can specify a query to find all documents that contain the term dog within a section you define as Headings.


Sections must be defined prior to indexing and specified with the section group preference.


Oracle Text provides section groups with system-defined section definitions for HTML and XML. You can also specify that the system automatically create sections from XML documents during indexing.









3.2.12 Stopwords and Stopthemes


A stopword is a word that is not to be indexed. Usually stopwords are low information words in a given language such as this and that in English.


By default, Oracle Text provides a list of stopwords called a stoplist for indexing a given language. You can modify this list or create your own with the CTX_DDL package. You specify the stoplist in the parameter string of CREATE INDEX.


A stoptheme is a word that is prevented from being theme-indexed or prevented from contributing to a theme. You can add stopthemes with the CTX_DDL package.


You can search document themes with the ABOUT operator. You can retrieve document themes programatically with the CTX_DOC PL/SQL package.





3.2.12.1 Language Detection and Stoplists


At query time, the language of the query is inherited from the query template, or from the session language (if no language is specified through the query template).








3.2.12.2 Multi-Language Stoplists


You can also create multi-language stoplists to hold language-specific stopwords. A multi-language stoplist is useful when you use the MULTI_LEXER to index a table that contains documents in different languages, such as English, German, and Japanese.


At index creation, the language column of each document is examined, and only the stopwords for that language are eliminated. At query time, the session language setting determines the active stopwords, like it determines the active lexer when using the multi-lexer.










3.2.13 Index Performance


There are factors that influence indexing performance including memory allocation, document format, degree of parallelism, and partitioned tables.









3.2.14 Query Performance and Storage of LOB Columns


If your table contains LOB structured columns that are frequently accessed in queries but rarely updated, you can improve query performance by storing these columns out of line.









Note:

You cannot map attributes to a remote LOB column.













3.2.15 Mixed Query Performance


If your CONTAINS() query also has structured predicates on the non-text columns, then you may consider having the Text index also index those column values. To do so, specify those columns in the FILTER BY clause of the CREATE INDEX statement. This enables Oracle Text to determine whether to have the structured predicate(s) also be processed by the Text index for better performance.


Additionally, if your CONTAINS() query has ORDER BY criteria on one or more structured columns, then the Text index can also index those column values. Specify those columns in the ORDER BY clause of the CREATE INDEX statement. This enables Oracle Text to determine whether to push the sort into the Text index for better query response time.











3.3 Creating Oracle Text Indexes


You can create four types of indexes with Oracle Text: CONTEXT, CTXCAT, and CTXRULE, and CTXXPATH. The section contains these topics:






3.3.1 Summary of Procedure for Creating a Text Index


By default, the system expects your documents to be stored in a text column. Once this requirement is satisfied, you can create a Text index using the CREATE INDEX SQL statement as an extensible index of type CONTEXT, without explicitly specifying any preferences. The system automatically detects your language, the datatype of the text column, format of documents, and sets indexing preferences accordingly.



To create an Oracle Text index:


  1. 

    Optionally, determine your custom indexing preferences, section groups, or stoplists if not using defaults. The following table describes these indexing classes:
    

    

    ClassDescription
    DatastoreHow are your documents stored?
    FilterHow can the documents be converted to plaintext?
    LexerWhat language is being indexed?
    WordlistHow should stem and fuzzy queries be expanded?
    StorageHow should the index data be stored?
    Stop ListWhat words or themes are not to be indexed?
    Section GroupHow are documents sections defined?
    

    

  2. 

    Optionally, create your own custom preferences, section groups, or stoplists. See "Creating Preferences".
    

  3. 

    Create the Text index with the SQL statement CREATE INDEX, naming your index and optionally specifying preferences. See "Creating a CONTEXT Index".
    










See Also:

"Considerations For Indexing" and CREATE INDEX topic in Oracle Text Reference












3.3.2 Creating Preferences


You can optionally create your own custom index preferences to override the defaults. Use the preferences to specify index information such as where your files are stored and how to filter your documents. You create the preferences then set the attributes.





3.3.2.1 Datastore Examples


The following sections give examples for setting direct, multi-column, URL, and file datastores.









See Also:

Oracle Text Reference for more information about data storage









3.3.2.1.1 Specifying DIRECT_DATASTORE


The following example creates a table with a CLOB column to store text data. It then populates two rows with text data and indexes the table using the system-defined preference CTXSYS.DEFAULT_DATASTORE which uses the DIRECT_DATASTORE preference type.


create table mytable(id number primary key, docs clob); 

insert into mytable values(111555,'this text will be indexed');
insert into mytable values(111556,'this is a default datastore example');
commit;

create index myindex on mytable(docs) 
  indextype is ctxsys.context 
  parameters ('DATASTORE CTXSYS.DEFAULT_DATASTORE');







3.3.2.1.2 Specifying MULTI_COLUMN_DATASTORE


The following example creates a multi-column datastore preference called my_multi on the three text columns to be concatenated and indexed:


begin
ctx_ddl.create_preference('my_multi', 'MULTI_COLUMN_DATASTORE');
ctx_ddl.set_attribute('my_multi', 'columns', 'column1, column2, column3');
end;







3.3.2.1.3 Specifying URL Data Storage


This example creates a URL_DATASTORE preference called my_url to which the http_proxy, no_proxy, and timeout attributes are set. The timeout attribute is set to 300 seconds. The defaults are used for the attributes that are not set.


begin
 ctx_ddl.create_preference('my_url','URL_DATASTORE');
 ctx_ddl.set_attribute('my_url','HTTP_PROXY','www-proxy.us.oracle.com');
 ctx_ddl.set_attribute('my_url','NO_PROXY','us.oracle.com');
 ctx_ddl.set_attribute('my_url','Timeout','300');
end;







3.3.2.1.4 Specifying File Data Storage


The following example creates a data storage preference using the FILE_DATASTORE. This tells the system that the files to be indexed are stored in the operating system. The example uses CTX_DDL.SET_ATTRIBUTE to set the PATH attribute of to the directory /docs.


begin
ctx_ddl.create_preference('mypref', 'FILE_DATASTORE');
ctx_ddl.set_attribute('mypref', 'PATH', '/docs'); 
end;









3.3.2.2 NULL_FILTER Example: Indexing HTML Documents


If your document set is entirely in HTML, then Oracle recommends that you use the NULL_FILTER in your filter preference, which does no filtering.


For example, to index an HTML document set, you can specify the system-defined preferences for NULL_FILTER and HTML_SECTION_GROUP as follows:


create index myindex on docs(htmlfile) indextype is ctxsys.context 
  parameters('filter ctxsys.null_filter
  section group ctxsys.html_section_group');







3.3.2.3 PROCEDURE_FILTER Example


Consider a filter procedure CTXSYS.NORMALIZE that you define with the following signature:


PROCEDURE NORMALIZE(id IN ROWID, charset IN VARCHAR2, input IN CLOB, 
output IN OUT NOCOPY VARCHAR2);



To use this procedure as your filter, you set up your filter preference as follows:


begin



ctx_ddl.create_preference('myfilt', 'procedure_filter');
ctx_ddl.set_attribute('myfilt', 'procedure', 'normalize');
ctx_ddl.set_attribute('myfilt', 'input_type', 'clob');
ctx_ddl.set_attribute('myfilt', 'output_type', 'varchar2');
ctx_ddl.set_attribute('myfilt', 'rowid_parameter', 'TRUE');
ctx_ddl.set_attribute('myfilt', 'charset_parameter', 'TRUE');



end;







3.3.2.4 BASIC_LEXER Example: Setting Printjoin Characters


Printjoin characters are non-alphanumeric characters that are to be included in index tokens, so that words such as web-site are indexed as web-site.



The following example sets printjoin characters to be the hyphen and underscore with the BASIC_LEXER:


begin
ctx_ddl.create_preference('mylex', 'BASIC_LEXER');
ctx_ddl.set_attribute('mylex', 'printjoins', '_-');
end;



To create the index with printjoins characters set as previously shown, enter the following statement:


create index myindex on mytable ( docs ) 
  indextype is ctxsys.context 
  parameters ( 'LEXER mylex' ); 







3.3.2.5 MULTI_LEXER Example: Indexing a Multi-Language Table



You use the MULTI_LEXER preference type to index a column containing documents in different languages. For example, you can use this preference type when your text column stores documents in English, German, and French.


The first step is to create the multi-language table with a primary key, a text column, and a language column as follows:


create table globaldoc (
   doc_id number primary key,
   lang varchar2(3),
   text clob
);



Assume that the table holds mostly English documents, with some German and Japanese documents. To handle the three languages, you must create three sub-lexers, one for English, one for German, and one for Japanese:


ctx_ddl.create_preference('english_lexer','basic_lexer');
ctx_ddl.set_attribute('english_lexer','index_themes','yes');
ctx_ddl.set_attribute('english_lexer','theme_language','english');

ctx_ddl.create_preference('german_lexer','basic_lexer');
ctx_ddl.set_attribute('german_lexer','composite','german');
ctx_ddl.set_attribute('german_lexer','mixed_case','yes');
ctx_ddl.set_attribute('german_lexer','alternate_spelling','german');

ctx_ddl.create_preference('japanese_lexer','japanese_vgram_lexer');



Create the multi-lexer preference:


ctx_ddl.create_preference('global_lexer', 'multi_lexer');



Because the stored documents are mostly English, make the English lexer the default using CTX_DDL.ADD_SUB_LEXER:


ctx_ddl.add_sub_lexer('global_lexer','default','english_lexer');



Now add the German and Japanese lexers in their respective languages with CTX_DDL.ADD_SUB_LEXER procedure. Also assume that the language column is expressed in the standard ISO 639-2 language codes, so add those as alternate values.


ctx_ddl.add_sub_lexer('global_lexer','german','german_lexer','ger');
ctx_ddl.add_sub_lexer('global_lexer','japanese','japanese_lexer','jpn');



Now create the index globalx, specifying the multi-lexer preference and the language column in the parameter clause as follows:


create index globalx on globaldoc(text) indextype is ctxsys.context
parameters ('lexer global_lexer language column lang');







3.3.2.6 BASIC_WORDLIST Example: Enabling Substring and Prefix Indexing


The following example sets the wordlist preference for prefix and substring indexing. Having a prefix and sub-string component to your index improves performance for wildcard queries.


For prefix indexing, the example specifies that Oracle Text create token prefixes between three and four characters long:


begin 



ctx_ddl.create_preference('mywordlist', 'BASIC_WORDLIST'); 
ctx_ddl.set_attribute('mywordlist','PREFIX_INDEX','TRUE');
ctx_ddl.set_attribute('mywordlist','PREFIX_MIN_LENGTH', '3');
ctx_ddl.set_attribute('mywordlist','PREFIX_MAX_LENGTH', '4');
ctx_ddl.set_attribute('mywordlist','SUBSTRING_INDEX', 'YES');



end;









3.3.3 Creating Section Groups for Section Searching


When documents have internal structure such as in HTML and XML, you can define document sections using embedded tags before you index. This enables you to query within the sections using the WITHIN operator. You define sections as part of a section group.





3.3.3.1 Example: Creating HTML Sections


The following code defines a section group called htmgroup of type HTML_SECTION_GROUP. It then creates a zone section in htmgroup called heading identified by the <H1> tag:


begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_zone_section('htmgroup', 'heading', 'H1');
end;












3.3.4 Using Stopwords and Stoplists


A stopword is a word that is not to be indexed. A stopword is usually a low information word such as this or that in English.


The system supplies a list of stopwords called a stoplist for every language. By default during indexing, the system uses the Oracle Text default stoplist for your language.


You can edit the default stoplist CTXSYS.DEFAULT_STOPLIST or create your own with the following PL/SQL procedures:


  • 

    CTX_DDL.CREATE_STOPLIST
    

  • 

    CTX_DDL.ADD_STOPWORD
    

  • 

    CTX_DDL.REMOVE_STOPWORD
    



You specify your custom stoplists in the parameter clause of CREATE INDEX.


You can also dynamically add stopwords after indexing with the ALTER INDEX statement.





3.3.4.1 Multi-Language Stoplists


You can create multi-language stoplists to hold language-specific stopwords. A multi-language stoplist is useful when you use the MULTI_LEXER to index a table that contains documents in different languages, such as English, German, and Japanese.


To create a multi-language stoplist, use the CTX_DLL.CREATE_STOPLIST procedure and specify a stoplist type of MULTI_STOPLIST. You add language specific stopwords with CTX_DDL.ADD_STOPWORD.








3.3.4.2 Stopthemes and Stopclasses


In addition to defining your own stopwords, you can define stopthemes, which are themes that are not to be indexed. This feature is available for English and French only.


You can also specify that numbers are not to be indexed. A class of alphanumeric characters such a numbers that is not to be indexed is a stopclass.


You record your own stopwords, stopthemes, stopclasses by creating a single stoplist, to which you add the stopwords, stopthemes, and stopclasses. You specify the stoplist in the paramstring for CREATE INDEX.








3.3.4.3 PL/SQL Procedures for Managing Stoplists


You use the following procedures to manage stoplists, stopwords, stopthemes, and stopclasses:


  • 

    CTX_DDL.CREATE_STOPLIST
    

  • 

    CTX_DDL.ADD_STOPWORD
    

  • 

    CTX_DDL.ADD_STOPTHEME
    

  • 

    CTX_DDL.ADD_STOPCLASS
    

  • 

    CTX_DDL.REMOVE_STOPWORD
    

  • 

    CTX_DDL.REMOVE_STOPTHEME
    

  • 

    CTX_DDL.REMOVE_STOPCLASS
    

  • 

    CTX_DDL.DROP_STOPLIST
    


    

    

    See Also:
    
Oracle Text Reference to learn more about using these statements
    

    











3.3.5 Creating a CONTEXT Index


The CONTEXT index type is well suited for indexing large coherent documents in formats such as Microsoft Word, HTML, or plain text. With a CONTEXT index, you can also customize your index in a variety of ways. The documents must be loaded in a text table.





3.3.5.1 CONTEXT Index and DML


A CONTEXT index is not transactional. When a record is deleted, the index change is immediate. That is, your own session will no longer find the record from the moment you make the change, and other users will not find the record as soon as you commit. For inserts and updates, the new information will not be visible to text searches until an index synchronization has occurred. Therefore, when you perform inserts or updates on the base table, you must explicitly synchronize the index with CTX_DDL.SYNC_INDEX.









3.3.5.2 Default CONTEXT Index Example


The following statement creates a default CONTEXT index called myindex on the text column in the docs table:


CREATE INDEX myindex ON docs(text) INDEXTYPE IS CTXSYS.CONTEXT;



When you use CREATE INDEX without explicitly specifying parameters, the system does the following actions by default for all languages:


  • 

    Assumes that the text to be indexed is stored directly in a text column. The text column can be of type CLOB, BLOB, BFILE, VARCHAR2, or CHAR.
    

  • 

    Detects the column type and uses filtering for the binary column types of BLOB and BFILE. Most document formats are supported for filtering. If your column is plain text, the system does not use filtering.
    


    

    

    Note:
    
For document filtering to work correctly in your system, you must ensure that your environment is set up correctly to support the AUTO_FILTER filter.

    To learn more about configuring your environment to use the AUTO_FILTER filter, see the Oracle Text Reference.
    

    

    

  • 

    Assumes the language of text to index is the language you specify in your database setup.
    

  • 

    Uses the default stoplist for the language you specify in your database setup. Stoplists identify the words that the system ignores during indexing.
    

  • 

    Enables fuzzy and stemming queries for your language, if this feature is available for your language.
    



You can always change the default indexing behavior by creating your own preferences and specifying these custom preferences in the parameter string of CREATE INDEX.








3.3.5.3 Incrementally Creating an Index with ALTER INDEX and CREATE INDEX


The ALTER INDEX and CREATE INDEX statements support incrementally creating a global CONTEXT index.


  • 

    For creating a global index, CREATE INDEX supports the NOPOPULATE keyword of the REBUILD clause. Using the NOPOPULATE keyword in the REPLACE parameter, you can create indexes incrementally. This is valuable for creating text indexes in large installations that cannot afford to have the indexing process running continuously.
    

  • 

    For creating a local index partition, ALTER INDEX ... REBUILD partition ... parameters ('REPLACE ...') parameter string is modified to support the NOPOPULATE keyword.
    

  • 

    For creating a partition on a local index, CREATE INDEX ... LOCAL ... (partition ... parameters ('NOPOPULATE')) is supported. The partition-level POPULATE or NOPOPULATE keywords override any POPULATE or NOPOPULATE specified at the index level.
    










See Also:

Oracle Text Reference to learn more about the syntax for the ALTER INDEX and CREATE INDEX statements












3.3.5.4 Creating a CONTEXT Index Incrementally with POPULATE_PENDING


For large installations that cannot afford to have the indexing process run continuously, you can use the CTX_DDL.POPULATE_PENDING procedure. This also provides finer control over creating the indexes. The preferred method is to create an empty index, place all the rowids into the pending queue, and build the index through CTX_DDL.SYNC_INDEX.


This procedure populates the pending queue with every rowid in the base table or table partition.









See Also:

Oracle Text Reference for information about CTX.DDL.POPULATE_PENDING












3.3.5.5 Custom CONTEXT Index Example: Indexing HTML Documents


To index an HTML document set located by URLs, you can specify the system-defined preference for the NULL_FILTER in the CREATE INDEX statement.


You can also specify your section group htmgroup that uses HTML_SECTION_GROUP and datastore my_url that uses URL_DATASTORE as follows:


begin
 ctx_ddl.create_preference('my_url','URL_DATASTORE');
 ctx_ddl.set_attribute('my_url','HTTP_PROXY','www-proxy.us.oracle.com');
 ctx_ddl.set_attribute('my_url','NO_PROXY','us.oracle.com');
 ctx_ddl.set_attribute('my_url','Timeout','300');
end;

begin
ctx_ddl.create_section_group('htmgroup', 'HTML_SECTION_GROUP');
ctx_ddl.add_zone_section('htmgroup', 'heading', 'H1');
end;



You can then index your documents as follows:


CREATE INDEX myindex on docs(htmlfile) indextype is ctxsys.context 
parameters(
'datastore my_url filter ctxsys.null_filter section group htmgroup'
);










See Also:

"Creating Preferences" for more examples on creating a custom context index












3.3.5.6 CONTEXT Index Example: Query Processing with FILTER BY and ORDER BY


To enable more efficient query processing and better response time for mixed queries, you can use FILTER BY and ORDER BY clauses as shown in the following example.


CREATE INDEX myindex on docs(text) INDEXTYPE is CTXSYS.CONTEXT
FILTER BY category, publisher, pub_date
ORDER BY pub_date desc;



In this example, by specifying the clause FILTER BY category, publisher, pub_date at query time, Oracle Text will also consider pushing any relational predicate on any of these columns into the Text index row source for more efficient query processing.


Also, when the query has matching ORDER BY criteria, by specifying ORDER BY pub_date desc, Oracle Text will determine whether to push the SORT into the Text index row source for better response time.










3.3.6 Creating a CTXCAT Index


The CTXCAT indextype is well-suited for indexing small text fragments and related information. If created correctly, this type of index can provide better structured query performance over a CONTEXT index.





3.3.6.1 CTXCAT Index and DML


A CTXCAT index is transactional. When you perform DML (inserts, updates, and deletes) on the base table, Oracle Text automatically synchronizes the index. Unlike a CONTEXT index, no CTX_DDL.SYNC_INDEX is necessary.









Note:

Applications that insert without invoking triggers such as SQL*Loader will not result in automatic index synchronization as described in this section.












3.3.6.2 About CTXCAT Sub-Indexes and Their Costs


A CTXCAT index comprises sub-indexes that you define as part of your index set. You create a sub-index on one or more columns to improve mixed query performance. However, adding sub-indexes to the index set has its costs. The time Oracle Text takes to create a CTXCAT index depends on its total size, and the total size of a CTXCAT index is directly related to the following factors:


  • 

    Total text to be indexed
    

  • 

    Number of sub-indexes in the index set
    

  • 

    Number of columns in the base table that make up the sub-indexes
    



Having many component indexes in your index set also degrades DML performance, because more indexes must be updated.


Because of the added index time and disk space costs for creating a CTXCAT index, carefully consider the query performance benefit that each component index gives your application before adding it to your index set.








3.3.6.3 Creating CTXCAT Sub-indexes


An online auction site that must store item descriptions, prices and bid-close dates for ordered look-up provides a good example for creating a CTXCAT index.




Figure 3-3 Auction Table Schema and CTXCAT Index

Description of Figure 3-3 follows

Description of "Figure 3-3 Auction Table Schema and CTXCAT Index"





Figure 3-3 shows a table called AUCTION with the following schema:


create table auction(



item_id number,
title varchar2(100),
category_id number,
price number,
bid_close date);





To create your sub-indexes, create an index set to contain them:


begin



ctx_ddl.create_index_set('auction_iset');



end;



Next, determine the structured queries your application is likely to enter. The CATSEARCH query operator takes a mandatory text clause and optional structured clause.


In our example, this means all queries include a clause for the title column which is the text column.


Assume that the structured clauses fall into the following categories:




Structured ClausesSub-index Definition to Serve QueryCategory
'price < 200'

'price = 150'


'order by price'

'price'A
'price = 100 order by bid_close'

'order by price, bid_close'

'price, bid_close'B








3.3.6.3.1 Structured Query Clause Category A


The structured query clause contains an expression for only the price column as follows:


SELECT FROM auction WHERE CATSEARCH(title, 'camera', 'price < 200')> 0;
SELECT FROM auction WHERE CATSEARCH(title, 'camera', 'price = 150')> 0;
SELECT FROM auction WHERE CATSEARCH(title, 'camera', 'order by price')> 0;



These queries can be served using sub-index B, but for efficiency you can also create a sub-index only on price, which we call sub-index A:


begin



ctx_ddl.add_index('auction_iset','price'); /* sub-index A */



end;







3.3.6.3.2 Structured Query Clause Category B


The structured query clause includes an equivalence expression for price ordered by bid_close, and an expression for ordering by price and bid_close in that order:


SELECT FROM auction WHERE CATSEARCH(
   title, 'camera','price = 100 
   ORDER BY bid_close')> 0;
SELECT FROM auction 
   WHERE CATSEARCH(
   title, 'camera','order by price, bid_close')> 0;



These queries can be served with a sub-index defined as follows:


begin



ctx_ddl.add_index('auction_iset','price, bid_close'); /* sub-index B */



end;



Like a combined b-tree index, the column order you specify with CTX_DDL.ADD_INDEX affects the efficiency and viability of the index scan Oracle Text uses to serve specific queries. For example, if two structured columns p and q have a b-tree index specified as 'p,q', Oracle Text cannot scan this index to sort 'ORDER BY q,p'.










3.3.6.4 Creating CTXCAT Index


The following example combines the previous examples and creates the index set preference with the two sub-indexes:


begin



ctx_ddl.create_index_set('auction_iset');
ctx_ddl.add_index('auction_iset','price'); /* sub-index A */
ctx_ddl.add_index('auction_iset','price, bid_close'); /* sub-index B */



end;



Figure 3-3 shows how the sub-indexes A and B are created from the auction table. Each sub-index is a b-tree index on the text column and the named structured columns. For example, sub-index A is an index on the title column and the bid_close column.


You create the combined catalog index with CREATE INDEX as follows:


CREATE INDEX auction_titlex ON AUCTION(title) 
  INDEXTYPE IS CTXSYS.CTXCAT 
  PARAMETERS ('index set auction_iset')
;










See Also:

Oracle Text Reference to learn more about creating a CTXCAT index with CREATEINDEX














3.3.7 Creating a CTXRULE Index


You use the CTXRULE index to build a document classification application. In such an application, a stream of incoming documents is classified based on their content. Document routing is achieved by creating a CTXRULE index on a table or queries. The queries define your categories. You can use the MATCHES operator to classify single documents.


This section contains the following steps toward creating a CTXRULE index and a simple document classification application:








See Also:

Chapter 6, "Classifying Documents in Oracle Text" for more information on document classification and the CTXRULE index








3.3.7.1 Step One: Create a Table of Queries


The first step is to create a table of queries that define your classifications. We create a table myqueries to hold the category name and query text:


CREATE TABLE myqueries (



queryid NUMBER PRIMARY KEY,
category VARCHAR2(30),
query VARCHAR2(2000)



);



Populate the table with the classifications and the queries that define each. For example, consider a classification for the subjects US Politics, Music, and Soccer.:


INSERT INTO myqueries VALUES(1, 'US Politics', 'democrat or republican');
INSERT INTO myqueries VALUES(2, 'Music', 'ABOUT(music)');
INSERT INTO myqueries VALUES(3, 'Soccer', 'ABOUT(soccer)');






3.3.7.1.1 Using CTX_CLS.TRAIN


You can also generate a table of rules (or queries) with the CTX_CLS.TRAIN procedure, which takes as input a document training set.









See Also:

Oracle Text Reference for more information on CTX_CLS.TRAIN














3.3.7.2 Step Two: Create the CTXRULE Index


Use CREATE INDEX to create the CTXRULE index. You can specify lexer, storage, section group, and wordlist parameters if needed:


CREATE INDEX ON myqueries(query)
     INDEXTYPE IS CTXRULE PARAMETERS
           ('lexer lexer_pref 
             storage storage_pref 
             section group section_pref 
             wordlist wordlist_pref');







3.3.7.3 Step Three: Classify a Document


With a CTXRULE index created on a query set, you can use the MATCHES operator to classify a document.


Assume that incoming documents are stored in the table news:


CREATE TABLE news ( 



newsid NUMBER,
author VARCHAR2(30),
source VARCHAR2(30),
article CLOB);





You can create a before insert trigger with MATCHES to route each document to another table news_route based on its classification:


BEGIN
  -- find matching queries
  FOR c1 IN (select category
               from myqueries
              where MATCHES(query, :new.article)>0) 
  LOOP
    INSERT INTO news_route(newsid, category)
      VALUES (:new.newsid, c1.category);
  END LOOP;
END;











3.4 Maintaining Oracle Text Indexes


This section describes maintaining your index in the event of an error or indexing failure. The following topics are included:






3.4.1 Viewing Index Errors


Sometimes an indexing operation might fail or not complete successfully. When the system encounters an error during indexing a row, it logs the error in an Oracle Text view.


You can view errors on your indexes with CTX_USER_INDEX_ERRORS. View errors on all indexes as CTXSYS with CTX_INDEX_ERRORS.


For example, to view the most recent errors on your indexes, enter the following statement:


SELECT err_timestamp, err_text 
  FROM ctx_user_index_errors 
  ORDER BY err_timestamp DESC;



To clear the view of errors, enter:


DELETE FROM ctx_user_index_errors;



This view is cleared automatically when you create a new index.









See Also:

Oracle Text Reference to learn more about these views












3.4.2 Dropping an Index


You must drop an existing index before you can re-create it with CREATE INDEX.


Drop an index using the DROP INDEX statement in SQL.


If you try to create an index with an invalid PARAMETERS string, then you still need to drop it before you can re-create it.


For example, to drop an index called newsindex, enter the following SQL statement:


DROP INDEX newsindex; 



If Oracle Text cannot determine the state of the index, for example as a result of an indexing malfunction, you cannot drop the index as described previously. Instead use:


DROP INDEX newsindex FORCE;










See Also:

Oracle Text Reference to learn more about this statement












3.4.3 Resuming Failed Index


You can sometimes resume a failed index creation operation using the ALTER INDEX statement. You typically resume a failed index after you have investigated and corrected the index failure. Not all index failures can be resumed.


Index optimization commits at regular intervals. Therefore, if an optimization operation fails, then all optimization work up to the commit point has already been saved.









See Also:

Oracle Text Reference to learn more about the ALTER INDEX statement syntax







Example: Resuming a Failed Index


The following statement resumes the indexing operation on newsindex with 10 megabytes of memory:


ALTER INDEX newsindex REBUILD PARAMETERS('resume memory 10M');







3.4.4 Re-creating an Index


This section describes the procedures available for re-creating an index, which enable index settings to be changed. During the re-creation process, the index can be queried normally.





3.4.4.1 Re-creating a Global Index


Oracle Text provides RECREATE_INDEX_ONLINE to re-create a CONTEXT index with new preeferences, while preserving the base table DML and query capability during the re-create process. You can use RECREATE_INDEX_ONLINE in a one step procedure to re-create a CONTEXT index online for global indexes. Because the new index is created alongside the existing index, this operation requires storage roughly equal to the size of the existing index. Also, because the RECREATE_INDEX_ONLINE operation is performed online, you may issue DML on the base table during the operation. All DML that occurs during re-creation is logged into an online pending queue.


  • 

    After the re-create index operation is complete, any new information resulting from DML during the re-creation process may not be immediately reflected. As with creating an index online, the index should be synchronized after the re-create index operation is complete in order to bring it fully up-to-date.
    

  • 

    Synchronizations issued against the index during the re-creation are processed against the old, existing data. Synchronizations are blocked during this time when queries return errors.
    

  • 

    Optimize commands issued against the index during the re-creation return immediately without error and without processing.
    

  • 

    During RECREATE_INDEX_ONLINE, the index can be queried normally most of the time. Queries return results based on the existing index and policy until after the final swap. Also, if you issue DML statements and synchronize them, then you will be able to see the new rows when you query on the existing index.
    










See Also:

Oracle Text Reference to learn more about the RECREATE_INDEX_ONLINE procedure













Note:

Transactional query is not supported with RECREATE_INDEX_ONLINE.







Re-creating a Local Partitioned Index


If the index is locally partitioned, you cannot re-create the index in one step. You must first create a shadow policy, and then run the RECREATE_INDEX_ONLINE procedure for every partition. You can specify SWAP or NOSWAP, which indicates whether re-creating the index for the partition will swap the index partition data and index partition metadata.


This procedure can also be used to update the metadata (for example the storage preference) of each partition when you specify NOPOPULATE in the parameter string. This is useful for incremental building of a shadow index through time-limited synchronization. If NOPOPULATE is specified, then NOSWAP is silently enforced.


  • 

    When all of the partitions use NOSWAP, the storage requirement is approximately equal to the size of the existing index. During the re-creation of the index partition, since no swapping is performed, queries on the partition are processed normally. Queries spanning multiple partitions return consistent results across partitions until the swapping stage is reached.
    

  • 

    When the partitions are rebuilt with SWAP, the storage requirement for the operation is equal to the size of the existing index partition. Since index partition data and metadata are swapped after re-creation, queries spanning multiple partitions will not return consistent results from partition to partition, but will always be correct with respect to each index partition.
    

  • 

    If SWAP is specified, then DML and synchronization on the partition are blocked during the swap process.
    










See Also:

Oracle Text Reference for complete information about RECREATE_INDEX_ONLINE







Re-creating a Global Index with Time Limit for Synch


You can control index re-creation to set a time limit for SYNC_INDEX during non-business hours and incrementally re-create the index. You use the CREATE_SHADOW_INDEX procedure with POPULATE_PENDING and maxtime.









See Also:

Oracle Text Reference for information and examples for CREATE_SHADOW_INDEX







Re-creating a Global Index with Scheduled Swap


With CTX_DDL.EXCHANGE_SHADOW_INDEX you can perform index re-creation during non-business hours when query failures and DML blocking can be tolerated.









See Also:

Oracle Text Reference for information and examples for CTX_DDL.EXCHANGE_SHADOW_INDEX







Re-creating a Local Index with All-at-Once Swap


You can re-create a local partitioned index online to create or change preferences. The swapping of the index and partition metadata occurs at the end of the process. Queries spanning multiple partitions return consistent results across partitions when re-create is in process, except at the end when EXCHANGE_SHADOW_INDEX is running.



Scheduling Local Index Re-creation with All-at-Once Swap


With RECREATE_INDEX_ONLINE of the CTX.DDL package, you can incrementally re-create a local partitioned index, where partitions are all swapped at the end.









See Also:

Oracle Text Reference for complete information and the example for this process with RECREATE_INDEX_ONLINE







Re-creating a Local Index with Per-Partition Swap


Instead of swapping all partitions at once, you can re-create the index online with new preferences, with each partition being swapped as it is completed. Queries across all partitions may return inconsistent results during this process. This procedure uses CREATE_SHADOW_INDEX with RECREATE_INDEX_ONLINE.









See Also:

Oracle Text Reference for an example of swapping index partitions with the RECREATE_INDEX_ONLINE procedure














3.4.5 Rebuilding an Index


You can rebuild a valid index using ALTER INDEX. Rebuilding an index does not allow most index settings to be changed. You might rebuild an index when you want to index with a new preference. Generally, there is no advantage in rebuilding an index over dropping it and re-creating it with CREATE INDEX.









See Also:

"Re-creating an Index" for information about changing index settings







Example: Rebuilding an Index


The following statement rebuilds the index, replacing the lexer preference with my_lexer.


ALTER INDEX newsindex REBUILD PARAMETERS('replace lexer my_lexer');







3.4.6 Dropping a Preference


You might drop a custom index preference when you no longer need it for indexing.


You drop index preferences with the procedure CTX_DDL.DROP_PREFERENCE.


Dropping a preference does not affect the index created from the preference.









See Also:

Oracle Text Reference to learn more about the syntax for the CTX_DDL.DROP_PREFERENCE procedure







Example: Dropping a Preference


The following code drops the preference my_lexer.


begin
ctx_ddl.drop_preference('my_lexer');
end;









3.5 Managing DML Operations for a CONTEXT Index


DML operations to the base table refer to when documents are inserted, updated, or deleted from the base table. This section describes how you can monitor, synchronize, and optimize the Oracle Text CONTEXT index when DML operations occur. This section contains the following topics:










Note:

CTXCAT indexes are transactional and, thus, they are updated immediately when there is a change to the base table. Manual synchronization as described in this section is not necessary for a CTXCAT index.









3.5.1 Viewing Pending DML


When documents in the base table are inserted or updated, their ROWIDs are held in a DML queue until you synchronize the index. You can view this queue with the CTX_USER_PENDING view.


For example, to view pending DML on all your indexes, enter the following statement:


SELECT pnd_index_name, pnd_rowid, to_char(
        pnd_timestamp, 'dd-mon-yyyy hh24:mi:ss'
        ) timestamp FROM ctx_user_pending;



This statement gives output in the form:


PND_INDEX_NAME                 PND_ROWID          TIMESTAMP
------------------------------ ------------------ --------------------
MYINDEX                        AAADXnAABAAAS3SAAC 06-oct-1999 15:56:50










See Also:

Oracle Text Reference to learn more about this view












3.5.2 Synchronizing the Index


Synchronizing the index involves processing all pending updates and inserts to the base table. You can do this in PL/SQL with the CTX_DDL.SYNC_INDEX procedure. The following sections describe how you can control the duration and locking behavior for synchronizing an index:






3.5.2.1 Example


The following example synchronizes the index with 2 megabytes of memory:


begin



ctx_ddl.sync_index('myindex', '2M');



end;










See Also:

Oracle Text Reference to learn more about the CTX_DDL.SYNC_INDEX statement syntax












3.5.2.2 Maxtime Parameter for SYNC_INDEX


The sync_index procedure includes a maxtime parameter that, like optimize_index, indicates a suggested time limit in minutes for the operation. The sync_index will process as many documents in the queue as possible within the given time limit.


  • 

    NULL maxtime is equivalent to CTX_DDL.MAXTIME_UNLIMITED.
    

  • 

    The time limit is approximate. The actual time taken may be somewhat less than, or greater than what you specify.
    

  • 

    There is no change to the ALTER INDEX... sync command, which is deprecated.
    

  • 

    The maxtime parameter is ignored when sync_index is invoked without an index name.
    

  • 

    The maxtime parameter cannot be communicated for automatic synchronizations (for example, sync on commit or sync every).
    









3.5.2.3 Locking Parameter for SYNC_INDEX


The locking parameter of sync_index enables you to configure how the synchronization deals with the scenario where another sync is already running on the index.


  • 

    The locking parameter is ignored when sync_index is invoked without an index name.
    

  • 

    The locking parameter cannot be communicated for automatic syncs (i.e. sync on commit/sync every)
    

  • 

    When locking mode is LOCK_WAIT, in the event of not being able to get a lock, it will wait forever and ignore the maxtime setting.
    



The options are as follows:




OptionDescription
CTX_DDL.LOCK_WAITIf another sync is running, wait until the running sync is complete, then begin new sync.
CTX_DDL.LOCK_NOWAITIf another sync is running, immediately return without error.
CTX_DDL.LOCK_NOWAIT_ERRORIf another sync is running, immediately raise an error (DRG-51313: timeout while waiting for DML or optimize lock).












3.5.3 Optimizing the Index


Frequent index synchronization ultimately causes fragmentation of your CONTEXT index. Index fragmentation can adversely affect query response time. You should, therefore, allow time to optimize your CONTEXT index in order to reduce fragmentation and index size and to ensure optimal query performance. To understand index optimization, you must understand the structure of the index and what happens when it is synchronized.





3.5.3.1 CONTEXT Index Structure


The CONTEXT index is an inverted index where each word contains the list of documents that contain that word. For example, after a single initial indexing operation, the word DOG might have an entry as follows:


DOG DOC1 DOC3 DOC5







3.5.3.2 Index Fragmentation


When new documents are added to the base table, the index is synchronized by adding new rows. Thus, if you add a new document (for example, DOC 7) with the word dog to the base table and synchronize the index, you now have:


DOG DOC1 DOC3 DOC5
DOG DOC7



Subsequent DML will also create new rows as follows:


DOG DOC1 DOC3 DOC5
DOG DOC7
DOG DOC9
DOG DOC11



Adding new documents and synchronizing the index causes index fragmentation. In particular, background DML, which synchronizes the index frequently, generally produces more fragmentation than synchronizing in batch mode.


Less frequent batch processing results in longer document lists, reducing the number of rows in the index and thus reducing fragmentation.


You can reduce index fragmentation by optimizing the index in either FULL or FAST mode with CTX_DDL.OPTIMIZE_INDEX.








3.5.3.3 Document Invalidation and Garbage Collection


When documents are removed from the base table, Oracle Text marks the document as removed but does not immediately alter the index.


Because the old information takes up space and can cause extra overhead at query time, you must remove the old information from the index by optimizing it in FULL mode. This is called garbage collection. Optimizing in FULL mode for garbage collection is necessary when you have frequent updates or deletes to the base table.








3.5.3.4 Single Token Optimization


In addition to optimizing the entire index, you can optimize single tokens. You can use token mode to optimize index tokens that are frequently searched, without spending time on optimizing tokens that are rarely referenced.


For example, you can specify that only the token DOG be optimized in the index, if you know that this token is updated and queried frequently.


An optimized token can improve query response time for the token.


To optimize an index in token mode, use CTX_DDL.OPTIMIZE_INDEX.








3.5.3.5 Viewing Index Fragmentation and Garbage Data


With the CTX_REPORT.INDEX_STATS procedure, you can create a statistical report on your index. The report includes information on optimal row fragmentation, a list of most fragmented tokens, and the amount of garbage data in your index. Although this report might take a long time to run for large indexes, it can help you decide whether to optimize your index.









See Also:

Oracle Text Reference to learn more about using this procedure












3.5.3.6 Examples: Optimizing the Index


To optimize an index, Oracle recommends that you use CTX_DDL.OPTIMIZE_INDEX.









See Also:

Oracle Text Reference for the CTX_DDL.OPTIMIZE_INDEX statement syntax and examples
















PKfa
eePK&AOEBPS/acatapp.htmY=

CATSEARCH Query Application



B CATSEARCH Query Application


This appendix describes how to build a simple Web-search application using the CATSEARCH index type, either by writing your own code or by using the Oracle Text Wizard. The following topics are covered:






B.1 CATSEARCH Web Query Application Overview


The CTXCAT index type is well suited for merchandise catalogs that have short descriptive text fragments and associated structured data. This appendix describes how to build a browser based bookstore catalog that users can search to find titles and prices.


This application is written in Java Server Pages (JSP).


The application can be produced by using a catalog query application wizard, which produces the necessary code automatically. You can view and download the JSP application code, as well as the catalog query application wizard, at the Oracle Technology Network Web site:


http://www.oracle.com/technology/products/text



This Web site also has complete instructions on how to use the catalog query wizard.








B.2 The JSP Web Application


This application is based on Java Server pages and has the following requirements:


  • 

    Your Oracle Database (version 8.1.7 or higher) is up and running.
    

  • 

    You have a Web server such as Apache up and running and correctly configured to send requests to Oracle Database.
    






B.2.1 Building the JSP Web Application


This application models an online bookstore where you can look up book titles and prices.


Step 1   Create Your Table


You must create the table to store book information such as title, publisher, and price. From SQL*Plus:


sqlplus>create table book_catalog (
          id        numeric,
          title     varchar2(80),
          publisher varchar2(25),
          price     numeric )

Step 2   Load data using SQL*Loader


Load the book data from the operating system command-line with SQL*Loader:


% sqlldr userid=ctxdemo/ctxdemo control=loader.ctl

Step 3   Create index set


You can create the index set from SQL*Plus:


sqlplus>begin
          ctx_ddl.create_index_set('bookset');
          ctx_ddl.add_index('bookset','price');
          ctx_ddl.add_index('bookset','publisher');
        end;
/

Step 4   Index creation


You can create the CTXCAT index from SQL*Plus as follows:


sqlplus>create index book_idx on book_catalog (title) 
        indextype is ctxsys.ctxcat
        parameters('index set bookset');

Step 5   Try a simple search using CATSEARCH


You can test the newly created index in SQL*Plus as follows:


sqlplus>select id, title from book_catalog 
        where catsearch(title,'Java','price > 10 order by price') > 0

Step 6   Copy the catalogSearch.jsp file to your Web site JSP directory.


When you do so, you can access the application from a browser. The URL should be http://localhost:port/path/catalogSearch.jsp


The application displays a query entry box in your browser and returns the query results as a list of HTML links. See Figure B-1.






Figure B-1 Screen shot of Web Query Application

Description of Figure B-1 follows

Description of "Figure B-1 Screen shot of Web Query Application"










B.2.2 JSP Sample Code


This section lists the code used to build the example Web application. It includes the following files:






B.2.2.1 loader.ctl


      LOAD DATA
        INFILE 'loader.dat'
        INTO TABLE book_catalog 
        REPLACE 
        FIELDS TERMINATED BY ';'
        (id, title, publisher, price)







B.2.2.2 loader.dat


1; A History of Goats; SPINDRIFT BOOKS;50
2; Robust Recipes Inspired by Eating Too Much;SPINDRIFT BOOKS;28
3; Atlas of Greenland History; SPINDRIFT BOOKS; 35
4; Bed and Breakfast Guide to Greenland; SPINDRIFT BOOKS; 37
5; Quitting Your Job and Running Away; SPINDRIFT BOOKS;25
6; Best Noodle Shops of Omaha ;SPINDRIFT BOOKS; 28
7; Complete Book of Toes; SPINDRIFT BOOKS;16
8; Complete Idiot's Guide to Nuclear Technology;SPINDRIFT BOOKS; 28
9; Java Programming for Woodland Animals; LOW LIFE BOOK CO; 10
10; Emergency Surgery Tips and Tricks;SPOT-ON PUBLISHING;10
11; Programming with Your Eyes Shut; KLONDIKE BOOKS; 10
12; Forest Fires of North America, 1858-1882; CALAMITY BOOKS; 11
13; Spanish in Twelve Minutes; WRENCH BOOKS 11
14; Better Sex and Romance Through C++; CALAMITY BOOKS; 12
15; Oracle Internet Application Server Enterprise Edition; KANT BOOKS; 12
16; Oracle Internet Developer Suite; SPAMMUS BOOK CO;13
17; Telling the Truth to Your Pets; IBEX BOOKS INC; 13
18; Go Ask Alice's Restaurant;HUMMING BOOKS;    13
19; Life Begins at 93;  CALAMITY BOOKS;   17
20; Dating While Drunk;  BALLAST BOOKS;  14
21; The Second-to-Last Mohican; KLONDIKE BOOKS;  14
22; Eye of Horus; An Oracle of Ancient Egypt; BIG LITTLE BOOKS;     15
23; Introduction to Sitting Down; IBEX BOOKS INC;  15







B.2.2.3 catalogSearch.jsp


<%@ page import="java.sql.* , oracle.jsp.dbutil.*" %>
<jsp:useBean id="name" class="oracle.jsp.jml.JmlString" scope="request" >
<jsp:setProperty name="name" property="value" param="v_query" />
</jsp:useBean>

<%
  String connStr="jdbc:oracle:thin:@machine-domain-name:1521:betadev";

  java.util.Properties info = new java.util.Properties();

  Connection conn = null;
  ResultSet  rset = null;
  Statement  stmt = null;


       if (name.isEmpty() ) { 

%>
           <html>
             <title>Catalog Search</title>
             <body>
             <center>
               <form method=post>
               Search for book title:
               <input type=text name="v_query" size=10>
               where publisher is
               <select name="v_publisher">
                  <option value="ADDISON WESLEY">ADDISON WESLEY
                  <option value="HUMMING BOOKS">HUMMING BOOKS
                  <option value="WRENCH BOOKS">WRENCH BOOKS
                  <option value="SPOT-ON PUBLISHING">SPOT-ON PUBLISHING
                  <option value="SPINDRIFT BOOKS">SPINDRIFT BOOKS
                  <option value="LOW LIFE BOOK CO">LOW LIFE BOOK CO
                  <option value="KLONDIKE BOOKS">KLONDIKE BOOKS
                  <option value="CALAMITY BOOKS">CALAMITY BOOKS
                  <option value="IBEX BOOKS INC">IBEX BOOKS INC
                  <option value="BIG LITTLE BOOKS">BIG LITTLE BOOKS
               </select>
               and price is 
               <select name="v_op">
                 <option value="=">=
                 <option value="&lt;">&lt;
                 <option value="&gt;">&gt;
               </select>
               <input type=text name="v_price" size=2>
               <input type=submit value="Search">
               </form>
             </center>
             <hr>
             </body>
           </html>

<%
      }
      else {

         String v_query = request.getParameter("v_query");
         String v_publisher = request.getParameter("v_publisher");
         String v_price = request.getParameter("v_price");
         String v_op    = request.getParameter("v_op");
%>

         <html>
           <title>Catalog Search</title>
           <body>
           <center>
            <form method=post action="catalogSearch.jsp">
            Search for book title:
            <input type=text name="v_query" value= 
            <%= v_query %>
            size=10>
            where publisher is
            <select name="v_publisher">
                  <option value="ADDISON WESLEY">ADDISON WESLEY
                  <option value="HUMMING BOOKS">HUMMING BOOKS
                  <option value="WRENCH BOOKS">WRENCH BOOKS
                  <option value="SPOT-ON PUBLISHING">SPOT-ON PUBLISHING
                  <option value="SPINDRIFT BOOKS">SPINDRIFT BOOKS
                  <option value="LOW LIFE BOOK CO">LOW LIFE BOOK CO
                  <option value="KLONDIKE BOOKS">KLONDIKE BOOKS
                  <option value="CALAMITY BOOKS">CALAMITY BOOKS
                  <option value="IBEX BOOKS INC">IBEX BOOKS INC
                  <option value="BIG LITTLE BOOKS">BIG LITTLE BOOKS
            </select>
            and price is 
            <select name="v_op">
               <option value="=">=
               <option value="&lt;">&lt;
               <option value="&gt;">&gt;
            </select>
            <input type=text name="v_price" value=
            <%= v_price %> size=2>
            <input type=submit value="Search">
            </form>
            </center>
          
<%
     try {

       DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver() );
       info.put ("user", "ctxdemo");
       info.put ("password","ctxdemo");
       conn = DriverManager.getConnection(connStr,info);

         stmt = conn.createStatement();
         String theQuery = request.getParameter("v_query");
         String thePrice = request.getParameter("v_price");

 // select id,title 
 // from book_catalog 
 // where catsearch (title,'Java','price >10 order by price') > 0

 // select title 
 // from book_catalog 
 // where catsearch(title,'Java','publisher = ''CALAMITY BOOKS'' 
          and price < 40 order by price' )>0

         String myQuery = "select title, publisher, price from book_catalog
             where catsearch(title, '"+theQuery+"', 
             'publisher = ''"+v_publisher+"'' and price "+v_op+thePrice+" 
             order by price' ) > 0";
         rset = stmt.executeQuery(myQuery);

         String color = "ffffff";

         String myTitle = null;
         String myPublisher = null;
         int myPrice = 0;
         int items = 0;

         while (rset.next()) {
            myTitle     = (String)rset.getString(1);
            myPublisher = (String)rset.getString(2);
            myPrice     = (int)rset.getInt(3);
            items++;

            if (items == 1) {
%>
               <center>
                  <table border="0">
                     <tr bgcolor="#6699CC">
                       <th>Title</th>
                       <th>Publisher</th>
                       <th>Price</th>
                     </tr>
<%
            }
%> 
            <tr bgcolor="#<%= color %>">
             <td> <%= myTitle %></td>
             <td> <%= myPublisher %></td>
             <td> $<%= myPrice %></td>
            </tr>
<%
            if (color.compareTo("ffffff") == 0)
               color = "eeeeee";
             else
               color = "ffffff";

      }
      
   } catch (SQLException e) {

%>

      <b>Error: </b> <%= e %><p>

<%

  } finally {
       if (conn != null) conn.close();
       if (stmt != null) stmt.close();
       if (rset != null) rset.close();
   }
   
%>
    </table>
    </center>
   </body>
   </html>
<%
 }
%>











PKoe;^=Y=PK&A
OEBPS/lot.htmQ

List of Tables



List of Tables







PK'VQPK

&Aoa,mimetypePK&A;/TO:iTunesMetadata.plistPK&AYuMETA-INF/container.xmlPK&AGCyoOEBPS/classify.htmPK&A[pTOOEBPS/cover.htmPK&At(KKEOEBPS/overview.htmPK&ALE@.OEBPS/title.htmPK&AqXO^@^OEBPS/query.htmPK&A}{~>OEBPS/img/ccapp016.gifPK&A֍A-COEBPS/aoptim.htmPK&AX
M+2-H
OEBPS/img_text/ccapp018.htmPK&Aw)id>M
OEBPS/img_text/search01b.htmPK&A8}
O
OEBPS/img_text/ccapp019.htmPK&A#ĜtoGR
OEBPS/img_text/ccapp016.htmPK&A&W
OEBPS/img_text/ccapp014.htmPK&A~|@;Y
OEBPS/img_text/pethilitb.htmPK&ACCj\
OEBPS/img_text/pet01b.htmPK&A8^
OEBPS/img_text/ccapp012.htmPK&ASu*
c
OEBPS/img_text/ccapp010.htmPK&A/<f
OEBPS/img_text/petthemeb.htmPK&A7'i
OEBPS/img_text/ccapp017.htmPK&A0l
OEBPS/img_text/ccapp015.htmPK&AGBp
OEBPS/img_text/petgist1b.htmPK&A+ds
OEBPS/img_text/search02b.htmPK&A$F&! v
OEBPS/img_text/qcatwiz1_newb.htmPK&AK^Yx
OEBPS/img_text/ccapp002.htmPK&Av8#|
OEBPS/img_text/ccapp011.htmPK&A.8m3m
OEBPS/quicktour.htmPK&A
-	
OEBPS/csection.htmPK&A83
OEBPS/toc.ncxPK&As$--FOEBPS/content.opfPK&Ats%# #/OEBPS/resultset.htmPK&A)##SOEBPS/cmigrt.htmPK&A_	hvOEBPS/dcommon/prodbig.gifPK&AY@
|OEBPS/dcommon/doclib.gifPK&Ahh~OEBPS/dcommon/oracle-logo.jpgPK&ACOEBPS/dcommon/contbig.gifPK&A.OEBPS/dcommon/darbbook.cssPK&AMά""!{OEBPS/dcommon/O_signature_clr.JPGPK&APzOEBPS/dcommon/feedbck2.gifPK&A-OEBPS/dcommon/feedback.gifPK&Aː5OEBPS/dcommon/booklist.gifPK&AN61vOEBPS/dcommon/cpyr.htmPK&A!:3.,OEBPS/dcommon/masterix.gifPK&AeӺ1,k.OEBPS/dcommon/doccd.cssPK&A7	0OEBPS/dcommon/larrow.gifPK&A#3OEBPS/dcommon/indxicon.gifPK&AS'"s5OEBPS/dcommon/leftnav.gifPK&Ahu,6OEBPS/dcommon/uarrow.gifPK&Al-OJ9OEBPS/dcommon/oracle.gifPK&A(BOEBPS/dcommon/index.gifPK&AGC		COEBPS/dcommon/bookbig.gifPK&AJV^MOEBPS/dcommon/rarrow.gifPK&A枰pkPOEBPS/dcommon/mix.gifPK&Ao"nR
M
ROEBPS/dcommon/doccd_epub.jsPK&Av
I
`]OEBPS/dcommon/toc.gifPK&A
r~$^OEBPS/dcommon/topnav.gifPK&A1FA`OEBPS/dcommon/prodicon.gifPK&A3(
#
cOEBPS/dcommon/bp_layout.cssPK&Ax[?:qOEBPS/dcommon/bookicon.gifPK&Ap*c^vOEBPS/dcommon/conticon.gifPK&AʍHzOEBPS/dcommon/blafdoc.cssPK&A+&GOEBPS/dcommon/rightnav.gifPK&Aje88OEBPS/dcommon/oracle-small.JPGPK&Aއ{&!OEBPS/dcommon/help.gifPK&A	  eOEBPS/search.htmPK&AK*ϱ
OEBPS/toc.htmPK&AhgOEBPS/view.htmPK&Afa
ee
OEBPS/ind.htmPK&Aoe;^=Y=yOEBPS/acatapp.htmPK&A'VQ
OEBPS/lot.htmPK]]J