The very simple technique to check weather mod_rewrite module is enabled or not in you web server.

1) Type in a php file and save it and run that file in the server.
2) And now you can the list of information, just search the word “mod_rewrite” from the browser’s search menu.
3) If it is found under the “Loaded Modules” section then this module is already loaded. Otherwise you need to enable mod_rewrite module.

To enable mod_rewrite module in apache installed under windows environment.

1) Find the “httpd.conf” file under the “conf” folder inside the Apache’s installation folder.
2) Find the following line “#LoadModule rewrite_module modules/mod_rewrite.so” in the “httpd.conf” file.
3) Remove the “#” at the starting of the line, “#” represents that line is commented.
4) Now restart the apache server.
5) You can see now “mod_rewrite” in the Loaded Module section while doing “phpinfo()”.

• Searchable email: An email application could let users search archived messages and add new messages to the index as they arrive.
• Online documentation search: A documentation reader — CD-based, Web-based, or embedded within the application — could let users search online documentation or archived publications.
• Searchable Webpages: A Web browser or proxy server could build a personal search engine to index every Webpage a user has visited, allowing users to easily revisit pages.
• Website search: A CGI program could let users search your Website.
• Content search: An application could let the user search saved documents for specific content; this could be integrated into the Open Document dialog.
• Version control and content management: A document management system could index documents, or document versions, so they can be easily retrieved.
• News and wire service feeds: A news server or relay could index articles as they arrive.
  

How search engines work?

Creating and maintaining an inverted index is the central problem when building an efficient keyword search engine. To index a document, you must first scan it to produce a list of postings. Postings describe occurrences of a word in a document; they generally include the word, a document ID, and possibly the location(s) or frequency of the word within the document.

What is Lucene?

• Apache Lucene is a high-performance, full-featured text search engine library written entirely in Java.
• It is a technology suitable for nearly any application that requires full-text search.

Facts

• Incremental versus batch indexing: Some search engines only support batch indexing; once they create an index for a set of documents, adding new documents becomes difficult without reindexing all the documents. Incremental indexing allows easy adding of documents to an existing index. For some applications, like those that handle live data feeds, incremental indexing is critical. Lucene supports both types of indexing.
• Data sources: Many search engines can only index files or Webpages. This handicaps applications where indexed data comes from a database, or where multiple virtual documents exist in a single file, such as a ZIP archive. Lucene allows developers to deliver the document to the indexer through a String or an InputStream, permitting the data source to be abstracted from the data. However, with this approach, the developer must supply the appropriate readers for the data.
• Indexing control: Some search engines can automatically crawl through a directory tree or a Website to find documents to index. While this is convenient if your data is already stored in this manner, crawler-based indexers often provide limited flexibility for applications that require fine-grained control over the indexed documents. Since Lucene operates primarily in incremental mode, it lets the application find and retrieve documents.
• File formats: Some search engines can only index text or HTML documents; others support a filter mechanism, which offers a simple alternative to indexing word processing documents, SGML documents, and other file formats. Lucene supports such a mechanism.
• Content tagging: Some search engines treat a document as a single stream of tokens; others allow the specification of multiple data fields within a document, such as “subject,” “abstract,” “author,” and “body.” This permits semantically richer queries like “author contains Hamilton AND body contains Constitution.” Lucene supports content tagging by treating documents as collections of fields, and supports queries that specify which field(s) to search.
• Stop-word processing: Common words, such as “a,” “and,” and “the,” add little value to a search index. But since these words are so common, cataloging them will contribute considerably to the indexing time and index size. Most search engines will not index certain words, called stop words. Some use a list of stop words, while others select stop words statistically. Lucene handles stop words with the more general Analyzer mechanism, to be described later, and provides the Stop Analyzer class, which eliminates stop words from the input stream.
• Stemming: Often, a user desires a query for one word to match other similar words. For example, a query for “jump” should probably also match the words “jumped,” “jumper,” or “jumps.” Reducing a word to its root form is called stemming. Lucene does not yet implement stemming, but you could easily add a stemmer through a more sophisticated Analyzer class.
• Query features: Search engines support a variety of query features. Some support full Boolean queries; others support only and queries. Some return a “relevance” score with each hit. Some can handle adjacency or proximity queries — “search followed by engine” or “Knicks near Celtics” — others can only search on single keywords. Some can search multiple indexes at once and merge the results to give a meaningful relevance score. Lucene supports a wide range of query features, including all of those listed above. However, Lucene does not support the valuable Soundex, or “sounds like,” query.
• Concurrency: Can multiple users search an index at the same time? Can a user search an index while another updates it? Lucene allows users to search an index transactionally, even if another user is simultaneously updating the index.
• Non-English support: Many search engines implicitly assume that English is the target language; this is evident in areas such as stop-word lists, stemming algorithms, and the use of proximity to match phrase queries. As Lucene preprocesses the input stream through the Analyzer class provided by the developer, it is possible to perform language-specific filtering.

Basic Definitions

The fundamental concepts in Lucene are

§          index

§          document

§          field

§          term

An index contains a sequence of documents.
A document is a sequence of fields.
A field is a named sequence of terms.|
A term is a string

The same string in two different fields is considered a different term.
 
Inverted index

• The index stores statistics about terms in order to make term-based search more efficient.
• Lucene’s index falls into the family of indexes known as an inverted index.
• This is because it can list, for a term, the documents that contain it.
• This is the inverse of the natural relationship, in which documents list terms.
  

Lucene indexes may be composed of multiple sub-indexes, or segments. Each segment is a fully independent index, which could be searched separately. 

Internally, Lucene refers to documents by an integer document number. The first document added to an index is numbered zero, and each subsequent document added gets a number one greater than the previous. 

Overview
Each segment index maintains the following: 

• Field names – This contains the set of field names used in the index.
• Stored Field values - This contains, for each document, a list of attribute-value pairs, where the attributes are field names. These are used to store auxiliary information about the document, such as its title, url, or an identifier to access a database. The set of stored fields are what is returned for each hit when searching. This is keyed by document number.
• Term dictionary – A dictionary containing all of the terms used in all of the indexed fields of all of the documents. The dictionary also contains the number of documents which contain the term, and pointers to the term’s frequency and proximity data.
• Term Frequency data – For each term in the dictionary, the numbers of all the documents that contain that term, and the frequency of the term in that document.
• Term Proximity data - For each term in the dictionary, the positions that the term occurs in each document.
• Normalization factors - For each field in each document, a value is stored that is multiplied into the score for hits on that field.
• Term Vectors - For each field in each document, the term vector (sometimes called document vector) may be stored. A term vector consists of term text and term frequency. To add Term Vectors to your index see the Field constructors
• Deleted documents - An optional file indicating which documents are deleted.
  

File Naming

• Typically in lucene, all segments in an index are stored in a single directory.
• All files belonging to a segment have the same name with varying extensions.
• File names are never reused.
• Segments Info File – The active segments in the index are stored in the segment info file
• Lock File – This lock file ensures that only one writer is modifying the index at a time.
• Deletable File – contained details about files that need to be deleted.
• Field Info File – Field names are stored in the field info file, with suffix .fnm.
• Field index File – This contains, for each document, a pointer to its field data. Suffix is .fdm
• Field Data File  - This contains the stored fields of each document. Suffix is .fdt
• Term Dictionary Files – The term dictionary is represented as two files, The term infos, or tis file and The term info index, or .tii file.
• Frequency File – The .frq file contains the lists of documents which contain each term, along with the frequency of the term in that document.
• Positions File – The .prx file contains the lists of positions that each term occurs at within documents.