I18N_Arabic
[ class tree: I18N_Arabic ] [ index: I18N_Arabic ] [ all elements ]
Packages:
I18N_Arabic

Source for file Query.php

Documentation is available at Query.php

  1. <?php
  2. /**
  3.  * ----------------------------------------------------------------------
  4.  *  
  5.  * Copyright (c) 2006-2013 Khaled Al-Sham'aa.
  6.  *  
  7.  * http://www.ar-php.org
  8.  *  
  9.  * PHP Version 5
  10.  *  
  11.  * ----------------------------------------------------------------------
  12.  *  
  13.  * LICENSE
  14.  *
  15.  * This program is open source product; you can redistribute it and/or
  16.  * modify it under the terms of the GNU Lesser General Public License (LGPL)
  17.  * as published by the Free Software Foundation; either version 3
  18.  * of the License, or (at your option) any later version.
  19.  *  
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU Lesser General Public License for more details.
  24.  *  
  25.  * You should have received a copy of the GNU Lesser General Public License
  26.  * along with this program.  If not, see <http://www.gnu.org/licenses/lgpl.txt>.
  27.  *  
  28.  * ----------------------------------------------------------------------
  29.  *  
  30.  * Class Name: Arabic Queary Class
  31.  *  
  32.  * Filename: Query.php
  33.  *  
  34.  * Original  Author(s): Khaled Al-Sham'aa <khaled@ar-php.org>
  35.  *  
  36.  * Purpose:  Build WHERE condition for SQL statement using MySQL REGEXP and
  37.  *           Arabic lexical  rules
  38.  *            
  39.  * ----------------------------------------------------------------------
  40.  *  
  41.  * Arabic Queary Class
  42.  *
  43.  * PHP class build WHERE condition for SQL statement using MySQL REGEXP and
  44.  * Arabic lexical  rules.
  45.  *    
  46.  * With the exception of the Qur'an and pedagogical texts, Arabic is generally
  47.  * written without vowels or other graphic symbols that indicate how a word is
  48.  * pronounced. The reader is expected to fill these in from context. Some of the
  49.  * graphic symbols include sukuun, which is placed over a consonant to indicate that
  50.  * it is not followed by a vowel; shadda, written over a consonant to indicate it is
  51.  * doubled; and hamza, the sign of the glottal stop, which can be written above or
  52.  * below (alif) at the beginning of a word, or on (alif), (waaw), (yaa'),
  53.  * or by itself on the line elsewhere. Also, common spelling differences regularly
  54.  * appear, including the use of (haa') for (taa' marbuuta) and (alif maqsuura)
  55.  * for (yaa'). These features of written Arabic, which are also seen in Hebrew as
  56.  * well as other languages written with Arabic script (such as Farsi, Pashto, and
  57.  * Urdu), make analyzing and searching texts quite challenging. In addition, Arabic
  58.  * morphology and grammar are quite rich and present some unique issues for
  59.  * information retrieval applications.
  60.  * 
  61.  * There are essentially three ways to search an Arabic text with Arabic queries:
  62.  * literal, stem-based or root-based.
  63.  * 
  64.  * A literal search, the simplest search and retrieval method, matches documents
  65.  * based on the search terms exactly as the user entered them. The advantage of this
  66.  * technique is that the documents returned will without a doubt contain the exact
  67.  * term for which the user is looking. But this advantage is also the biggest
  68.  * disadvantage: many, if not most, of the documents containing the terms in
  69.  * different forms will be missed. Given the many ambiguities of written Arabic, the
  70.  * success rate of this method is quite low. For example, if the user searches
  71.  * for (kitaab, book), he or she will not find documents that only
  72.  * contain (`al-kitaabu, the book).
  73.  * 
  74.  * Stem-based searching, a more complicated method, requires some normalization of
  75.  * the original texts and the queries. This is done by removing the vowel signs,
  76.  * unifying the hamza forms and removing or standardizing the other signs.
  77.  * Additionally, grammatical affixes and other constructions which attach directly
  78.  * to words, such as conjunctions, prepositions, and the definite article, should be
  79.  * identified and removed. Finally, regular and irregular plural forms need to be
  80.  * identified and reduced to their singular forms. Performing this type of stemming
  81.  * leads to more successful searches, but can be problematic due to over-generation
  82.  * or incorrect generation of stems.
  83.  * 
  84.  * A third method for searching Arabic texts is to index and search for the root
  85.  * forms of each word. Since most verbs and nouns in Arabic are derived from
  86.  * triliteral (or, rarely, quadriliteral) roots, identifying the underlying root of
  87.  * each word theoretically retrieves most of the documents containing a given search
  88.  * term regardless of form. However, there are some significant challenges with this
  89.  * approach. Determining the root for a given word is extremely difficult, since it
  90.  * requires a detailed morphological, syntactic and semantic analysis of the text to
  91.  * fully disambiguate the root forms. The issue is complicated further by the fact
  92.  * that not all words are derived from roots. For example, loan words (words
  93.  * borrowed from another language) are not based on root forms, although there are
  94.  * even exceptions to this rule. For example, some loans that have a structure
  95.  * similar to triliteral roots, such as the English word film, are handled
  96.  * grammatically as if they were root-based, adding to the complexity of this type
  97.  * of search. Finally, the root can serve as the foundation for a wide variety of
  98.  * words with related meanings. The root (k-t-b) is used for many words related
  99.  * to writing, including (kataba, to write), (kitaab, book), (maktab,
  100.  * office), and (kaatib, author). But the same root is also used for regiment/
  101.  * battalion, (katiiba). As a result, searching based on root forms results in
  102.  * very high recall, but precision is usually quite low.
  103.  * 
  104.  * While search and retrieval of Arabic text will never be an easy task, relying on
  105.  * linguistic analysis tools and methods can help make the process more successful.
  106.  * Ultimately, the search method you choose should depend on how critical it is to
  107.  * retrieve every conceivable instance of a word or phrase and the resources you
  108.  * have to process search returns in order to determine their true relevance.
  109.  * 
  110.  * Source: Volume 13 Issue 7 of MultiLingual Computing &
  111.  * Technology published by MultiLingual Computing, Inc., 319 North First Ave.,
  112.  * Sandpoint, Idaho, USA, 208-263-8178, Fax: 208-263-6310.
  113.  * 
  114.  * Example:
  115.  * <code>
  116.  *     include('./I18N/Arabic.php');
  117.  *     $obj = new I18N_Arabic('Query');
  118.  *     
  119.  *     $dbuser = 'root';
  120.  *     $dbpwd = '';
  121.  *     $dbname = 'test';
  122.  *     
  123.  *     try {
  124.  *         $dbh = new PDO('mysql:host=localhost;dbname='.$dbname, $dbuser, $dbpwd);
  125.  * 
  126.  *         // Set the error reporting attribute
  127.  *         $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  128.  * 
  129.  *         $dbh->exec("SET NAMES 'utf8'");
  130.  *     
  131.  *         if ($_GET['keyword'] != '') {
  132.  *             $keyword = @$_GET['keyword'];
  133.  *             $keyword = str_replace('\"', '"', $keyword);
  134.  *     
  135.  *             $obj->setStrFields('headline');
  136.  *             $obj->setMode($_GET['mode']);
  137.  *     
  138.  *             $strCondition = $Arabic->getWhereCondition($keyword);
  139.  *         } else {
  140.  *             $strCondition = '1';
  141.  *         }
  142.  *     
  143.  *         $StrSQL = "SELECT `headline` FROM `aljazeera` WHERE $strCondition";
  144.  * 
  145.  *         $i = 0;
  146.  *         foreach ($dbh->query($StrSQL) as $row) {
  147.  *             $headline = $row['headline'];
  148.  *             $i++;
  149.  *             if ($i % 2 == 0) {
  150.  *                 $bg = "#f0f0f0";
  151.  *             } else {
  152.  *                 $bg = "#ffffff";
  153.  *             }
  154.  *             echo "<tr bgcolor=\"$bg\"><td>$headline</td></tr>";
  155.  *         }
  156.  * 
  157.  *         // Close the databse connection
  158.  *         $dbh = null;
  159.  * 
  160.  *     } catch (PDOException $e) {
  161.  *         echo $e->getMessage();
  162.  *     }
  163.  * </code>
  164.  * 
  165.  * @category  I18N
  166.  * @package   I18N_Arabic
  167.  * @author    Khaled Al-Sham'aa <khaled@ar-php.org>
  168.  * @copyright 2006-2013 Khaled Al-Sham'aa
  169.  *    
  170.  * @license   LGPL <http://www.gnu.org/licenses/lgpl.txt>
  171.  * @link      http://www.ar-php.org
  172.  */
  173.  
  174. // New in PHP V5.3: Namespaces
  175. // namespace I18N\Arabic;
  176. // 
  177. // $obj = new I18N\Arabic\Query();
  178. // 
  179. // use I18N\Arabic;
  180. // $obj = new Arabic\Query();
  181. //
  182. // use I18N\Arabic\Query as Query;
  183. // $obj = new Query();
  184.  
  185. /**
  186.  * This PHP class build WHERE condition for SQL statement using MySQL REGEXP and
  187.  * Arabic lexical  rules
  188.  *  
  189.  * @category  I18N
  190.  * @package   I18N_Arabic
  191.  * @author    Khaled Al-Sham'aa <khaled@ar-php.org>
  192.  * @copyright 2006-2013 Khaled Al-Sham'aa
  193.  *    
  194.  * @license   LGPL <http://www.gnu.org/licenses/lgpl.txt>
  195.  * @link      http://www.ar-php.org
  196.  */ 
  197. class I18N_Arabic_Query
  198. {
  199.     private $_fields          = array();
  200.     private $_lexPatterns     = array();
  201.     private $_lexReplacements = array();
  202.  
  203.     /**
  204.      * Loads initialize values
  205.      */         
  206.     public function __construct()
  207.     {
  208.         $xml = simplexml_load_file(dirname(__FILE__).'/data/ArQuery.xml'); 
  209.          
  210.         foreach ($xml->xpath("//preg_replace[@function='__construct']/pair")
  211.                  as $pair) { 
  212.  
  213.                  array_push($this->_lexPatterns, (string)$pair->search); 
  214.             array_push($this->_lexReplacements, (string)$pair->replace); 
  215.         }
  216.     }
  217.     
  218.     /**
  219.      * Setting value for $_fields array
  220.      *      
  221.      * @param array $arrConfig Name of the fields that SQL statement will search
  222.      *                          them (in array format where items are those
  223.      *                          fields names)
  224.      *                       
  225.      * @return object $this to build a fluent interface
  226.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  227.      */
  228.     public function setArrFields($arrConfig)
  229.     {
  230.         if (is_array($arrConfig)) {
  231.             // Get _fields array
  232.             $this->_fields = $arrConfig;
  233.         }
  234.         
  235.         return $this;
  236.     }
  237.     
  238.     /**
  239.      * Setting value for $_fields array
  240.      *      
  241.      * @param string $strConfig Name of the fields that SQL statement will search
  242.      *                           them (in string format using comma as delimated)
  243.      *                          
  244.      * @return object $this to build a fluent interface
  245.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  246.      */
  247.     public function setStrFields($strConfig)
  248.     {
  249.         if (is_string($strConfig)) {
  250.             // Get _fields array
  251.             $this->_fields = explode(',', $strConfig);
  252.         }
  253.  
  254.         return $this;
  255.     }
  256.     
  257.     /**
  258.      * Setting $mode propority value that refer to search mode
  259.      * [0 for OR logic | 1 for AND logic]
  260.      *      
  261.      * @param integer $mode Setting value to be saved in the $mode propority
  262.      *      
  263.      * @return object $this to build a fluent interface
  264.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  265.      */
  266.     public function setMode($mode)
  267.     {
  268.         if (in_array($mode, array('0', '1'))) {
  269.             // Set search mode [0 for OR logic | 1 for AND logic]
  270.             $this->mode = $mode;
  271.         }
  272.         
  273.         return $this;
  274.     }
  275.     
  276.     /**
  277.      * Getting $mode propority value that refer to search mode
  278.      * [0 for OR logic | 1 for AND logic]
  279.      *      
  280.      * @return integer Value of $mode properity
  281.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  282.      */
  283.     public function getMode()
  284.     {
  285.         // Get search mode value [0 for OR logic | 1 for AND logic]
  286.         return $this->mode;
  287.     }
  288.     
  289.     /**
  290.      * Getting values of $_fields Array in array format
  291.      *      
  292.      * @return array Value of $_fields array in Array format
  293.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  294.      */
  295.     public function getArrFields()
  296.     {
  297.         $fields = $this->_fields;
  298.         
  299.         return $fields;
  300.     }
  301.     
  302.     /**
  303.      * Getting values of $_fields array in String format (comma delimated)
  304.      *      
  305.      * @return string Values of $_fields array in String format (comma delimated)
  306.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  307.      */
  308.     public function getStrFields()
  309.     {
  310.         $fields = implode(',', $this->_fields);
  311.         
  312.         return $fields;
  313.     }
  314.     
  315.     /**
  316.      * Build WHERE section of the SQL statement using defind lex's rules, search
  317.      * mode [AND | OR], and handle also phrases (inclosed by "") using normal
  318.      * LIKE condition to match it as it is.
  319.      *      
  320.      * @param string $arg String that user search for in the database table
  321.      *                    
  322.      * @return string The WHERE section in SQL statement
  323.      *                 (MySQL database engine format)
  324.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  325.      */
  326.     public function getWhereCondition($arg)
  327.     {
  328.         $sql = '';
  329.         $arg = mysql_escape_string($arg);
  330.         
  331.         // Check if there are phrases in $arg should handle as it is
  332.         $phrase = explode("\"", $arg);
  333.         
  334.         if (count($phrase) > 2) {
  335.             // Re-init $arg variable
  336.             // (It will contain the rest of $arg except phrases).
  337.             $arg = '';
  338.             
  339.             for ($i = 0; $i < count($phrase); $i++) {
  340.                 $subPhrase = $phrase[$i]; 
  341.                 if ($i % 2 == 0 && $subPhrase != '') {
  342.                     // Re-build $arg variable after restricting phrases
  343.                     $arg .= $subPhrase;
  344.                 } elseif ($i % 2 == 1 && $subPhrase != '') {
  345.                     // Handle phrases using reqular LIKE matching in MySQL
  346.                     $this->wordCondition[] = $this->getWordLike($subPhrase);
  347.                 }
  348.             }
  349.         }
  350.         
  351.         // Handle normal $arg using lex's and regular expresion
  352.         $words = preg_split('/\s+/', trim($arg));
  353.         
  354.         foreach ($words as $word) {
  355.             //if (is_numeric($word) || strlen($word) > 2) {
  356.                 // Take off all the punctuation
  357.                 //$word = preg_replace("/\p{P}/", '', $word);
  358.                 $exclude = array('(', ')', '[', ']', '{', '}', ',', ';', ':', 
  359.                                  '?', '!', '،', '؛', '؟');
  360.                 $word    = str_replace($exclude, '', $word);
  361.  
  362.                 $this->wordCondition[] = $this->getWordRegExp($word);
  363.             //}
  364.         }
  365.         
  366.         if (!empty($this->wordCondition)) {
  367.             if ($this->mode == 0) {
  368.                 $sql = '(' . implode(') OR (', $this->wordCondition) . ')';
  369.             } elseif ($this->mode == 1) {
  370.                 $sql = '(' . implode(') AND (', $this->wordCondition) . ')';
  371.             }
  372.         }
  373.         
  374.         return $sql;
  375.     }
  376.     
  377.     /**
  378.      * Search condition in SQL format for one word in all defind fields using
  379.      * REGEXP clause and lex's rules
  380.      *      
  381.      * @param string $arg String (one word) that you want to build a condition for
  382.      *      
  383.      * @return string sub SQL condition (for internal use)
  384.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  385.      */
  386.     protected function getWordRegExp($arg)
  387.     {
  388.         $arg = $this->lex($arg);
  389.         //$sql = implode(" REGEXP '$arg' OR ", $this->_fields) . " REGEXP '$arg'";
  390.         $sql = ' REPLACE(' . 
  391.                implode(", 'ـ', '') REGEXP '$arg' OR REPLACE(", $this->_fields) . 
  392.                ", 'ـ', '') REGEXP '$arg'";
  393.  
  394.         
  395.         return $sql;
  396.     }
  397.     
  398.     /**
  399.      * Search condition in SQL format for one word in all defind fields using
  400.      * normal LIKE clause
  401.      *      
  402.      * @param string $arg String (one word) that you want to build a condition for
  403.      *      
  404.      * @return string sub SQL condition (for internal use)
  405.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  406.      */
  407.     protected function getWordLike($arg)
  408.     {
  409.         $sql = implode(" LIKE '$arg' OR ", $this->_fields) . " LIKE '$arg'";
  410.         
  411.         return $sql;
  412.     }
  413.     
  414.     /**
  415.      * Get more relevant order by section related to the user search keywords
  416.      *      
  417.      * @param string $arg String that user search for in the database table
  418.      *                    
  419.      * @return string sub SQL ORDER BY section
  420.      * @author Saleh AlMatrafe <saleh@saleh.cc>
  421.      */
  422.     public function getOrderBy($arg)
  423.     {
  424.         // Check if there are phrases in $arg should handle as it is
  425.         $phrase = explode("\"", $arg);
  426.         if (count($phrase) > 2) {
  427.             // Re-init $arg variable 
  428.             // (It will contain the rest of $arg except phrases).
  429.             $arg = '';
  430.             for ($i = 0; $i < count($phrase); $i++) {
  431.                 if ($i % 2 == 0 && $phrase[$i] != '') {
  432.                     // Re-build $arg variable after restricting phrases
  433.                     $arg .= $phrase[$i];
  434.                 } elseif ($i % 2 == 1 && $phrase[$i] != '') {
  435.                     // Handle phrases using reqular LIKE matching in MySQL
  436.                     $wordOrder[] = $this->getWordLike($phrase[$i]);
  437.                 }
  438.             }
  439.         }
  440.         
  441.         // Handle normal $arg using lex's and regular expresion
  442.         $words = explode(' ', $arg);
  443.         foreach ($words as $word) {
  444.             if ($word != '') {
  445.                 $wordOrder[] = 'CASE WHEN ' . 
  446.                                $this->getWordRegExp($word) . 
  447.                                ' THEN 1 ELSE 0 END';
  448.             }
  449.         }
  450.         
  451.         $order = '((' . implode(') + (', $wordOrder) . ')) DESC';
  452.         
  453.         return $order;
  454.     }
  455.  
  456.     /**
  457.      * This method will implement various regular expressin rules based on
  458.      * pre-defined Arabic lexical rules
  459.      *      
  460.      * @param string $arg String of one word user want to search for
  461.      *      
  462.      * @return string Regular Expression format to be used in MySQL query statement
  463.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  464.      */
  465.     protected function lex($arg)
  466.     {
  467.         $arg = preg_replace($this->_lexPatterns, $this->_lexReplacements, $arg);
  468.         
  469.         return $arg;
  470.     }
  471.     
  472.     /**
  473.      * Get most possible Arabic lexical forms for a given word
  474.      *      
  475.      * @param string $word String that user search for
  476.      *      
  477.      * @return string list of most possible Arabic lexical forms for a given word
  478.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  479.      */
  480.     protected function allWordForms($word) 
  481.     {
  482.         $wordForms = array($word);
  483.         
  484.         $postfix1 = array('كم', 'كن', 'نا', 'ها', 'هم', 'هن');
  485.         $postfix2 = array('ين', 'ون', 'ان', 'ات', 'وا');
  486.         
  487.         $len = mb_strlen($word);
  488.  
  489.         if (mb_substr($word, 0, 2) == 'ال') {
  490.             $word = mb_substr($word, 2);
  491.         }
  492.         
  493.         $wordForms[] = $word;
  494.  
  495.         $str1 = mb_substr($word, 0, -1);
  496.         $str2 = mb_substr($word, 0, -2);
  497.         $str3 = mb_substr($word, 0, -3);
  498.  
  499.         $last1 = mb_substr($word, -1);
  500.         $last2 = mb_substr($word, -2);
  501.         $last3 = mb_substr($word, -3);
  502.         
  503.         if ($len >= 6 && $last3 == 'تين') {
  504.             $wordForms[] = $str3;
  505.             $wordForms[] = $str3 . 'ة';
  506.             $wordForms[] = $word . 'ة';
  507.         }
  508.         
  509.         if ($len >= 6 && ($last3 == 'كما' || $last3 == 'هما')) {
  510.             $wordForms[] = $str3;
  511.             $wordForms[] = $str3 . 'كما';
  512.             $wordForms[] = $str3 . 'هما';
  513.         }
  514.  
  515.         if ($len >= 5 && in_array($last2, $postfix2)) {
  516.             $wordForms[] = $str2;
  517.             $wordForms[] = $str2.'ة';
  518.             $wordForms[] = $str2.'تين';
  519.  
  520.             foreach ($postfix2 as $postfix) {
  521.                 $wordForms[] = $str2 . $postfix;
  522.             }
  523.         }
  524.  
  525.         if ($len >= 5 && in_array($last2, $postfix1)) {
  526.             $wordForms[] = $str2;
  527.             $wordForms[] = $str2.'ي';
  528.             $wordForms[] = $str2.'ك';
  529.             $wordForms[] = $str2.'كما';
  530.             $wordForms[] = $str2.'هما';
  531.  
  532.             foreach ($postfix1 as $postfix) {
  533.                 $wordForms[] = $str2 . $postfix;
  534.             }
  535.         }
  536.  
  537.         if ($len >= 5 && $last2 == 'ية') {
  538.             $wordForms[] = $str1;
  539.             $wordForms[] = $str2;
  540.         }
  541.  
  542.         if (($len >= 4 && ($last1 == 'ة' || $last1 == 'ه' || $last1 == 'ت')) 
  543.             || ($len >= 5 && $last2 == 'ات')
  544.         ) {
  545.             $wordForms[] = $str1;
  546.             $wordForms[] = $str1 . 'ة';
  547.             $wordForms[] = $str1 . 'ه';
  548.             $wordForms[] = $str1 . 'ت';
  549.             $wordForms[] = $str1 . 'ات';
  550.         }
  551.         
  552.         if ($len >= 4 && $last1 == 'ى') {
  553.             $wordForms[] = $str1 . 'ا';
  554.         }
  555.  
  556.         $trans = array('أ' => 'ا', 'إ' => 'ا', 'آ' => 'ا');
  557.         foreach ($wordForms as $word) {
  558.             $normWord = strtr($word, $trans);
  559.             if ($normWord != $word) {
  560.                 $wordForms[] = $normWord;
  561.             }
  562.         }
  563.         
  564.         $wordForms = array_unique($wordForms);
  565.         
  566.         return $wordForms;
  567.     }
  568.     
  569.     /**
  570.      * Get most possible Arabic lexical forms of user search keywords
  571.      *      
  572.      * @param string $arg String that user search for
  573.      *                    
  574.      * @return string list of most possible Arabic lexical forms for given keywords
  575.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  576.      */
  577.     public function allForms($arg)
  578.     {
  579.         $wordForms = array();
  580.         $words     = explode(' ', $arg);
  581.         
  582.         foreach ($words as $word) {
  583.             $wordForms = array_merge($wordForms, $this->allWordForms($word));
  584.         }
  585.         
  586.         $str = implode(' ', $wordForms);
  587.         
  588.         return $str;
  589.     }
  590. }
Documentation generated on Mon, 14 Jan 2013 17:49:03 +0100 by phpDocumentor 1.4.0