Source for file SqlFilters.php

Documentation is available at SqlFilters.php

  1. <?php
  2.     /**
  3.      * The standard filters
  4.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  5.      * @package MIPHPF
  6.      */
  7.     
  8.     /**
  9.      * Include the db class
  10.      */
  11.     if (class_exists('miStaticDBUtil', false) == false) {
  12.         require_once(dirname(__FILE__) . '/../database/StaticDBUtil.php');
  13.     }
  14.     
  15.     /**
  16.      * Abstract base sql filter class
  17.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  18.      * @package MIPHPF
  19.      */
  20.     abstract class miSqlFilter {
  21.         /**
  22.          * The filter name
  23.          */
  24.         protected $_name;
  25.         
  26.         /**
  27.          * Creates miSqlFilter object
  28.          * 
  29.          * @param string $name 
  30.          */
  31.         public function __construct($name)
  32.         {
  33.             $this->_name = $name;
  34.         }
  35.         
  36.         /**
  37.          * Returns the name of the filter
  38.          * 
  39.          * @return string 
  40.          */
  41.         public function getName()
  42.         {
  43.             return $this->_name;
  44.         }
  45.         
  46.         /**
  47.          * Returns the sql field names
  48.          * Used by miSqlRecordset to validate the fields are valid
  49.          * 
  50.          * @access public
  51.          * @return array the field names
  52.          */
  53.         public function getSqlFields()
  54.         {
  55.             return array($this->_name);
  56.         }
  57.         
  58.         /**
  59.          * Returns the sql for the filter
  60.          * Return empty string if the filter doesn't want to add filter clause
  61.          * Abstract method
  62.          * 
  63.          * @access public
  64.          * @return string the sql code for the filter
  65.          */
  66.         abstract public function getSql();
  67.     }
  68.     
  69.     /**
  70.      * Abstract filter class for filters with one parametized value
  71.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  72.      * @package MIPHPF
  73.      */
  74.     abstract class miSqlFilterOneValue extends miSqlFilter {
  75.         /**
  76.          * The filter value
  77.          */
  78.         protected $_value;
  79.         
  80.         /**
  81.          * Construct the filter
  82.          * 
  83.          * @param string $name 
  84.          * @param string $value 
  85.          */
  86.         public function __construct($name, $value)
  87.         {
  88.             $this->_value = $value;
  89.             parent::__construct($name);
  90.         }
  91.         
  92.         /**
  93.          * Returns the filter value
  94.          * 
  95.          * @return string the filter value
  96.          */
  97.         public function getValue()
  98.         {
  99.             return $this->_value;
  100.         }
  101.     }
  102.     
  103.     /**
  104.      * Filter for matching substrings. Uses the like operator
  105.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  106.      * @package MIPHPF
  107.      */
  108.     class miSqlFilterSubstring extends miSqlFilterOneValue {
  109.         public function getSql()
  110.         {
  111.             if ($this->_value == '')
  112.                 return '';
  113.             return sql_escape_string($this->_name) . ' LIKE "%' . sql_escape_string($this->_value) . '%"';
  114.         }
  115.     }
  116.     
  117.     /**
  118.      * Filter for matching the begining of strings. Uses the like operator
  119.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  120.      * @package MIPHPF
  121.      */
  122.     class miSqlFilterStarts extends miSqlFilterOneValue {
  123.         public function getSql()
  124.         {
  125.             if ($this->_value == '')
  126.                 return '';
  127.             return sql_escape_string($this->_name) . ' LIKE "' . sql_escape_string($this->_value) . '%"';
  128.         }
  129.     }
  130.     
  131.     /**
  132.      * Filter for matching the endings of strings. Uses the like operator
  133.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  134.      * @package MIPHPF
  135.      */
  136.     class miSqlFilterEnds extends miSqlFilterOneValue {
  137.         public function getSql()
  138.         {
  139.             if ($this->_value == '')
  140.                 return '';
  141.             return sql_escape_string($this->_name) . ' LIKE "%' . sql_escape_string($this->_value) . '"';
  142.         }
  143.     }
  144.     
  145.     /**
  146.      * Base filter class for simple comparion operator filters
  147.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  148.      * @package MIPHPF
  149.      */
  150.     class miSqlFilterSimple extends miSqlFilterOneValue {
  151.         /**
  152.          * The filter operator. The subclasses define it
  153.          */
  154.         protected $_operator;
  155.         
  156.         public function getSql()
  157.         {
  158.             if ((string)$this->_value == '')
  159.                 return '';
  160.             return sql_escape_string($this->_name) . $this->_operator . '"' . sql_escape_string($this->_value) . '"';
  161.         }
  162.     }
  163.     
  164.     /**
  165.      * 
  166.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  167.      * @package MIPHPF
  168.      */
  169.     class miSqlFilterEqual extends miSqlFilterSimple {
  170.         protected $_operator = '=';
  171.     }
  172.     
  173.     /**
  174.      * 
  175.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  176.      * @package MIPHPF
  177.      */
  178.     class miSqlFilterNotEqual extends miSqlFilterSimple {
  179.         protected $_operator = '!=';
  180.     }
  181.     
  182.     /**
  183.      * Simple filter for the > (bigger than) operator
  184.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  185.      * @package MIPHPF
  186.      */
  187.     class miSqlFilterBiggerThan extends miSqlFilterSimple {
  188.         protected $_operator = '>';
  189.     }
  190.     
  191.     /**
  192.      * Simple filter for the >= (bigger or equal) operator
  193.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  194.      * @package MIPHPF
  195.      */
  196.     class miSqlFilterBiggerOrEqual extends miSqlFilterSimple {
  197.         protected $_operator = '>=';
  198.     }
  199.     
  200.     /**
  201.      * Simple filter for the < (smaller than) operator
  202.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  203.      * @package MIPHPF
  204.      */
  205.     class miSqlFilterSmallerThan extends miSqlFilterSimple {
  206.         protected $_operator = '<';
  207.     }
  208.     
  209.     /**
  210.      * Simple filter for the <= (smaller or equal) operator
  211.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  212.      * @package MIPHPF
  213.      */
  214.     class miSqlFilterSmallerOrEqual extends miSqlFilterSimple {
  215.         protected $_operator = '<=';
  216.     }
  217.     
  218.     /**
  219.      * Regular expression filter
  220.      * 
  221.      * Please note that regexp operator is not portable.
  222.      * Some databases use the ANSI "similar to" operator, and others don't support regular expressions at all.
  223.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  224.      * @package MIPHPF
  225.      */
  226.     class miSqlFilterRegExp extends miSqlFilterSimple {
  227.         protected $_operator = ' REGEXP ';
  228.     }
  229.  
  230.  
  231.     /**
  232.      * Filter checking that the field is equal to any of the vaues
  233.      * The values are expected to be separated by comma
  234.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  235.      * @package MIPHPF
  236.      */
  237.     class miSqlFilterIn extends miSqlFilterOneValue {
  238.         protected $_operator = ' IN ';
  239.         
  240.         public function getSql()
  241.         {
  242.             if (is_array($this->_value)) {
  243.                 $values = $this->_value;
  244.             } else {
  245.                 if ($this->_value == '')
  246.                     return '';
  247.                 $values = explode(',', $this->_value);
  248.             }
  249.             foreach ($values as $key => $value) {
  250.                 $values[$key] = sql_escape_string($value);
  251.             }
  252.             return sql_escape_string($this->_name) . $this->_operator . '("' . implode('","', $values) . '")';
  253.         }
  254.     }
  255.     
  256.     /**
  257.      * Filter checking that the field is not equal to any of the vaues
  258.      * The values are expected to be separated by comma
  259.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  260.      * @package MIPHPF
  261.      */
  262.     class miSqlFilterNotIn extends miSqlFilterIn {
  263.         protected $_operator = ' NOT IN ';
  264.     }
  265.     
  266.     
  267.     /**
  268.      * Sql filter with custom SQL code
  269.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  270.      * @package MIPHPF
  271.      */
  272.     class miSqlFilterCustom extends miSqlFilter {
  273.         /**
  274.          * The custom sql code
  275.          */
  276.         protected $_sql;
  277.         
  278.         /**
  279.          * Creates miSqlFilter object
  280.          * 
  281.          * @access public
  282.          * @param string $name 
  283.          */
  284.         public function __construct($name, $sql)
  285.         {
  286.             $this->_sql = $sql;
  287.             parent::__construct($name);
  288.         }
  289.         
  290.         /**
  291.          * Returns the sql code
  292.          * 
  293.          * @access public
  294.          * @return string the custom sql code
  295.          */
  296.         public function getSql()
  297.         {
  298.             return $this->_sql;
  299.         }
  300.     }
  301. ?>

Documentation generated on Thu, 08 May 2008 16:57:33 +0300 by phpDocumentor 1.4.1