libraries/Types.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * SQL data types definition
   5  *
   6  * @package PhpMyAdmin
   7  */
   8 namespace PMA\libraries;
   9
  10 /**
  11  * Generic class holding type definitions.
  12  *
  13  * @package PhpMyAdmin
  14  */
  15 class Types
  16 {
  17     /**
  18      * Returns list of unary operators.
  19      *
  20      * @return string[]
  21      */
  22     public function getUnaryOperators()
  23     {
  24         return array(
  25             'IS NULL',
  26             'IS NOT NULL',
  27             "= ''",
  28             "!= ''",
  29         );
  30     }
  31
  32     /**
  33      * Check whether operator is unary.
  34      *
  35      * @param string $op operator name
  36      *
  37      * @return boolean
  38      */
  39     public function isUnaryOperator($op)
  40     {
  41         return in_array($op, $this->getUnaryOperators());
  42     }
  43
  44     /**
  45      * Returns list of operators checking for NULL.
  46      *
  47      * @return string[]
  48      */
  49     public function getNullOperators()
  50     {
  51         return array(
  52             'IS NULL',
  53             'IS NOT NULL',
  54         );
  55     }
  56
  57     /**
  58      * ENUM search operators
  59      *
  60      * @return string[]
  61      */
  62     public function getEnumOperators()
  63     {
  64         return array(
  65             '=',
  66             '!=',
  67         );
  68     }
  69
  70     /**
  71      * TEXT search operators
  72      *
  73      * @return string[]
  74      */
  75     public function getTextOperators()
  76     {
  77         return array(
  78             'LIKE',
  79             'LIKE %...%',
  80             'NOT LIKE',
  81             '=',
  82             '!=',
  83             'REGEXP',
  84             'REGEXP ^...$',
  85             'NOT REGEXP',
  86             "= ''",
  87             "!= ''",
  88             'IN (...)',
  89             'NOT IN (...)',
  90             'BETWEEN',
  91             'NOT BETWEEN',
  92         );
  93     }
  94
  95     /**
  96      * Number search operators
  97      *
  98      * @return string[]
  99      */
 100     public function getNumberOperators()
 101     {
 102         return array(
 103             '=',
 104             '>',
 105             '>=',
 106             '<',
 107             '<=',
 108             '!=',
 109             'LIKE',
 110             'LIKE %...%',
 111             'NOT LIKE',
 112             'IN (...)',
 113             'NOT IN (...)',
 114             'BETWEEN',
 115             'NOT BETWEEN',
 116         );
 117     }
 118
 119     /**
 120      * Returns operators for given type
 121      *
 122      * @param string  $type Type of field
 123      * @param boolean $null Whether field can be NULL
 124      *
 125      * @return string[]
 126      */
 127     public function getTypeOperators($type, $null)
 128     {
 129         $ret = array();
 130         $class = $this->getTypeClass($type);
 131
 132         if (strncasecmp($type, 'enum', 4) == 0) {
 133             $ret = array_merge($ret, $this->getEnumOperators());
 134         } elseif ($class == 'CHAR') {
 135             $ret = array_merge($ret, $this->getTextOperators());
 136         } else {
 137             $ret = array_merge($ret, $this->getNumberOperators());
 138         }
 139
 140         if ($null) {
 141             $ret = array_merge($ret, $this->getNullOperators());
 142         }
 143
 144         return $ret;
 145     }
 146
 147     /**
 148      * Returns operators for given type as html options
 149      *
 150      * @param string  $type             Type of field
 151      * @param boolean $null             Whether field can be NULL
 152      * @param string  $selectedOperator Option to be selected
 153      *
 154      * @return string Generated Html
 155      */
 156     public function getTypeOperatorsHtml($type, $null, $selectedOperator = null)
 157     {
 158         $html = '';
 159
 160         foreach ($this->getTypeOperators($type, $null) as $fc) {
 161             if (isset($selectedOperator) && $selectedOperator == $fc) {
 162                 $selected = ' selected="selected"';
 163             } else {
 164                 $selected = '';
 165             }
 166             $html .= '<option value="' . htmlspecialchars($fc)  . '"'
 167                 . $selected . '>'
 168                 . htmlspecialchars($fc)  . '</option>';
 169         }
 170
 171         return $html;
 172     }
 173
 174     /**
 175      * Returns the data type description.
 176      *
 177      * @param string $type The data type to get a description.
 178      *
 179      * @return string
 180      *
 181      */
 182     public function getTypeDescription($type)
 183     {
 184         return '';
 185     }
 186
 187     /**
 188      * Returns class of a type, used for functions available for type
 189      * or default values.
 190      *
 191      * @param string $type The data type to get a class.
 192      *
 193      * @return string
 194      *
 195      */
 196     public function getTypeClass($type)
 197     {
 198         return '';
 199     }
 200
 201     /**
 202      * Returns array of functions available for a class.
 203      *
 204      * @param string $class The class to get function list.
 205      *
 206      * @return string[]
 207      *
 208      */
 209     public function getFunctionsClass($class)
 210     {
 211         return array();
 212     }
 213
 214     /**
 215      * Returns array of functions available for a type.
 216      *
 217      * @param string $type The data type to get function list.
 218      *
 219      * @return string[]
 220      *
 221      */
 222     public function getFunctions($type)
 223     {
 224         $class = $this->getTypeClass($type);
 225         return $this->getFunctionsClass($class);
 226     }
 227
 228     /**
 229      * Returns array of all functions available.
 230      *
 231      * @return string[]
 232      *
 233      */
 234     public function getAllFunctions()
 235     {
 236         $ret = array_merge(
 237             $this->getFunctionsClass('CHAR'),
 238             $this->getFunctionsClass('NUMBER'),
 239             $this->getFunctionsClass('DATE'),
 240             $this->getFunctionsClass('UUID')
 241         );
 242         sort($ret);
 243         return $ret;
 244     }
 245
 246     /**
 247      * Returns array of all attributes available.
 248      *
 249      * @return string[]
 250      *
 251      */
 252     public function getAttributes()
 253     {
 254         return array();
 255     }
 256
 257     /**
 258      * Returns array of all column types available.
 259      *
 260      * @return string[]
 261      *
 262      */
 263     public function getColumns()
 264     {
 265         // most used types
 266         return array(
 267             'INT',
 268             'VARCHAR',
 269             'TEXT',
 270             'DATE',
 271         );
 272     }
 273
 274     /**
 275      * Returns an array of integer types
 276      *
 277      * @return string[] integer types
 278      */
 279     public function getIntegerTypes()
 280     {
 281         return array();
 282     }
 283
 284     /**
 285      * Returns the min and max values of a given integer type
 286      *
 287      * @param string  $type   integer type
 288      * @param boolean $signed whether signed
 289      *
 290      * @return string[] min and max values
 291      */
 292     public function getIntegerRange($type, $signed = true)
 293     {
 294         return array('', '');
 295     }
 296 }