sandbox/crell/pdo.php

<?php

error_reporting(E_ALL | E_STRICT);

define('DEBUG', TRUE);

function debug($msg, $label = 'DEBUG', $stealth = FALSE) {
  if (defined('DEBUG') && DEBUG) {
    if (is_bool($msg)) $msg = $msg ? 'TRUE' : 'FALSE';
    $display = $stealth ? ' style="display: none;"' : '';
    $backtrace = debug_backtrace();
    $debug = array();
    $stack = (isset($backtrace[1]['class']) ? "{$backtrace[1]['class']}::" : '')
    	. (isset($backtrace[1]['function']) ? "{$backtrace[1]['function']}" : '');
    if ($stack) $debug[] = $stack;
    $debug[] = "Line {$backtrace[0]['line']} of {$backtrace[0]['file']}";
    $debug = implode('<br />', $debug);
    print "<pre{$display}>{$label}: {$debug}:<br />" . print_r($msg, 1) . "</pre><br />\n";
  }
}

//debug(False, 'Something here', TRUE);

/**
 * Base Database API class.
 * 
 * This class provides a Drupal-specific extension of the PDO database abstraction class in PHP.
 * All database access calls should be issued statically against this class.  It acts as a Factory,
 * returning the appropriate child class for a specific database implmentation based on the
 * values of the global $db_url array.  
 *
 */
abstract class Database extends PDO {

  /**
   * The format for getting a random number in this particular database.
   *
   * @var string
   */
  static public $rand;
  
  /**
   * The date() foramt code needed to convert a unix timestamp int
   * the native timestamp format of this database.
   *
   * @var unknown_type
   */
  static public $timestamp;
  
  /**
   * The date() format code to turn a unix timestamp into
   * the native date format of the database.
   *
   * @var string
   */
  static public $time;
  
  static protected $connections = array();

  static protected $dbUrls = NULL;

  static $activeKey = 'default';

  function __construct($dsn, $username = "", $password = "", $driver_options = array()) {
    $driver_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION; // Because the other methods don't seem to work right.
    parent::__construct($dsn, $username, $password, $driver_options);
    $this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('DBStatement' , array($this)));
  }

  public static function getActiveConnection($target = 'default') {
    return self::getConnection(self::$activeKey, $target);
  }

  public static function setActiveConnection($key = 'default') {
    $old_key = self::$activeKey;
    self::$activeKey = $key;
    return $old_key;
  }

  /**
   * Parse out the database URLs specified in the config file 
   * and specify defaults where necessary.
   */
  protected static function parseUrls() {
    global $db_url;
    self::$dbUrls = $db_url;
    if (! is_array(self::$dbUrls)) {
      self::$dbUrls = array('default' => self::$dbUrls);
    }
    foreach (self::$dbUrls as $index => $url) {
      if (! is_array(self::$dbUrls[$index])) {
        self::$dbUrls[$index] = array('default' => $url);
      }
      foreach (self::$dbUrls[$index] as $target => $value) {
        // Each target can also be an array.  If it is, we select one entry at random to be
        // target for this request.  That allows us to have multiple slave servers.
        if (is_array($value)) {
          self::$dbUrls[$index][$target] = self::$dbUrls[$index][$target][mt_rand(0, count(self::$dbUrls[$index][$target]) - 1)];
        }
      }
    }
  }

  /**
   * Open a connection to the server specified by the given
   * key and target.
   *
   * @param $key
   * @param $target
   */
  protected static function openConnection($key, $target) {
    // Expand out the connection URLs to extended syntax.  It makes the parsing
    // later easier if we take care of all of the conditionals here, once.
    if (! isset(self::$db_urls)) {
      self::parseUrls();
    }
    
    // If the requested database does not exist then it is an unrecoverable error.
    // If the requested target does not exist, however, we fall back to the default
    // target.  The target is typically either "default" or "slave", indicating to
    // use a slave SQL server if one is available.  If it's not available, then the
    // default/master server is the correct server to use.
    if (! isset(self::$dbUrls[$key])) {
      throw new Exception('DB does not exist');
    }
    if (! isset(self::$dbUrls[$key][$target])) {
      $target = 'default';
    }
    
    // Parse out the connection URL so we can build our connection object.
    $url = parse_url(self::$dbUrls[$key][$target]);
    // Decode url-encoded information in the db connection string.
    $url['user'] = urldecode($url['user']);
    // Test if database url has a password.
    $url['pass'] = isset($url['pass']) ? urldecode($url['pass']) : '';
    $url['host'] = urldecode($url['host']);
    $url['path'] = urldecode($url['path']);
    // Allow for non-standard port.
    if (isset($url['port'])) {
      $url['host'] = $url['host'] . ':' . $url['port'];
    }
    
    // Each supported database type has its own child class for database-specific operations.
    // Instantiate and return an object of that class, which will still present a unified API.
    $db_type = 'Database_' . $url['scheme'];
    try {
      self::$connections[$key][$target] = new $db_type($url);
    } catch (PDOException $e) {
    	debug($e->getMessage());
      //watchdog('database', $e->getMessage());
      // print some sort of error here.
    }
  }

  public static function getConnection($key = 'default', $target = 'default') {
    
    if (! isset(self::$connections[$key][$target])) {
      self::openConnection($key, $target);
    }
    
    return self::$connections[$key][$target];
  }

  /**
   * Append a database prefix to all tables in a query.
   *
   * Queries sent to Drupal should wrap all table names in curly brackets. This
   * function searches for this syntax and adds Drupal's table prefix to all
   * tables, allowing Drupal to coexist with other systems in the same database if
   * necessary.
   *
   * @param $sql
   *   A string containing a partial or entire SQL query.
   * @return
   *   The properly-prefixed string.
   */
  protected function prefixTables($sql) {
    global $db_prefix;
    
    if (is_array($db_prefix)) {
      if (array_key_exists('default', $db_prefix)) {
        $tmp = $db_prefix;
        unset($tmp['default']);
        foreach ($tmp as $key => $val) {
          $sql = strtr($sql, array('{' . $key . '}' => $val . $key));
        }
        return strtr($sql, array('{' => $db_prefix['default'] , '}' => ''));
      } else {
        foreach ($db_prefix as $key => $val) {
          $sql = strtr($sql, array('{' . $key . '}' => $val . $key));
        }
        return strtr($sql, array('{' => '' , '}' => ''));
      }
    } else {
      return strtr($sql, array('{' => $db_prefix , '}' => ''));
    }
  }

  protected function runQuery($query, Array $args, $options, $return_affected = FALSE) {
    
    static $statements = array();
    
    $query = self::prefixTables($query);
    
    // Cache each prepared statement, keyed by the query itself.  This way,
    // we get the benefit of prepared statement caching without any extra
    // work by the module author.
    if (! isset($statements[$query])) {
      $statements[$query] = $this->prepare($query);
    }
    
    $options += Database::defaultOptions();
    $statements[$query]->execute($args, $options);
    
    
    if ($return_affected) {
      return $statements[$query]->rowCount();
    } else {
      return $statements[$query];
    }
  }

  /**
   * Execute a SELECT query on this database object.
   *
   * @param $query
   *   A string containing an SQL query.
   * @param $args
   *  An array of values to substitute into the query at placeholder markers.
   * @param $options
   *  An array of options on the query.  This array is assumed to have all
   *  values populated.
   * @return
   *   A database query result resource, or FALSE if the query was not executed
   *   correctly.
   */
  public function query($query, Array $args, Array $options) {
    
    // Backward compatibility hack, temporary.
    $query = str_replace(array('%d' , '%f' , '%b' , "'%s'"), '?', $query);
    
    return $this->runQuery($query, $args, $options);
  }

  /**
   * Run an insert query on this database object.
   *
   * @param $table
   *   The database table on which to run the insert query.
   * @param $fields
   *   An associative array of the values to insert.  The keys are the
   *   fields, and the corresponding values are the values to insert.
   * @return
   *   A   database query result resource, or FALSE if the query was not
   * executed correctly.
   *
   */
  function insert($table, Array $fields, $delay = FALSE) {
    $insert_fields = array_keys($fields);
    $insert_values = array_values($fields);
    
    $placeholders = array_fill(0, count($insert_values), '?');
    
    $num_affected = $this->runQuery('INSERT INTO {' . $table . '} (' . implode(',', $insert_fields) . ') VALUES (' . implode(',', $placeholders) . ')', $insert_values, array(), TRUE);
    return $this->lastInsertId();
  }

  /**
   * Build the WHERE portion of an SQL query, based on the specified values.
   *
   * @todo Add support for non-equality comparisons.
   * @param $where
   *   Associative array of rules in the WHERE clause.  If a key in the array
   *   is numeric, the value is taken as a literal rule.  If it is non-numeric,
   *   then it is assumed to be a field name and the corresponding value is the
   *   value that it must hold.
   * @param $where_type
   *   Whether the values of the WHERE clause should be ANDed or ORed together.
   *
   *   As an example, this $where clause would be translated as follows:
   *   $where = array('name'=>'foo', 'type'=>'page', 'created < 1147567877')
   *
   *   WHERE (name='foo') AND ('type'='page') AND (created < 1147567877')
   * @return
   *   An array containing the where clause with sprintf() markers, and
   *   an array of values to substitute for them.
   */
   static function where(Array $where, $where_type = 'AND', $where_keyword = TRUE) {
    $params = array();
    $args = array();
    foreach ($where as $key => $value) {
      if (is_numeric($key)) {
        $params[] = $value;
      } else {
        switch ($key) {
          case 'or':
            list ($sub_params, $sub_args) = self::where($value, 'OR', FALSE);
            $params[] = ' (' . $sub_params . ') ';
            $args = array_merge($args, $sub_args);
            break;
          case 'and':
            list ($sub_params, $sub_args) = self::where($value, 'AND', FALSE);
            $params[] = ' (' . $sub_params . ') ';
            $args = array_merge($args, $sub_args);
            break;
          case 'not':
            list ($sub_params, $sub_args) = self::where($value, 'AND', FALSE);
            $params[] = ' NOT (' . $sub_params . ') ';
            $args = array_merge($args, $sub_args);
            break;
          case '<':
            $operator = '<';
            $params[] = ' (' . key($value) . $operator . '?) ';
            $args[] = current($value);
            break;
          case '>':
            $operator = '>';
            $params[] = ' (' . key($value) . $operator . '?) ';
            $args[] = current($value);
            break;
          case '<=':
            $operator = '<=';
            $params[] = ' (' . key($value) . $operator . '?) ';
            $args[] = current($value);
            break;
          case '>=':
            $operator = '>=';
            $params[] = ' (' . key($value) . $operator . '?) ';
            $args[] = current($value);
            break;
          default:
            $operator = '=';
            if (is_array($value)) {
              $params[] = ' (' . $key . ' IN (' . array_fill(0, count($value), '?');
              array_merge($args, $value);
            } else {
              $params[] = ' (' . $key . $operator . '?) ';
              $args[] = $value;
            }
            break;
        }
      }
    }
    
    $return = '';
    if (sizeof($params)) {
      $return = ($where_keyword ? ' WHERE ' : ' ') . implode($where_type, $params);
    }
    
    return array($return , $args);
  }

  /**
   * Run an update query on this database object.
   *
   * @param $table
   *   The database table on which to run the update query.
   * @param $fields
   *   An associative array of the values to update.  The keys are the
   *   fields, and the corresponding values are the values to update to.
   * @param $where
   *   The where rules for this update query.
   * @param $where_type
   *   Whether to AND or OR the where rules together.
   * @return
   *   A database query result resource, or FALSE if the query was not
   *   executed correctly.
   *
   */
  function update($table, Array $fields, Array $where, $where_type = 'AND') {
    
    $update_values = array();
    $flat_fields = array();
    
    foreach ($fields as $field => $value) {
      $update_values[] = $value;
      $flat_fields[] = $field . '=?';
    }
    
    list ($where_string, $where_values) = self::where($where, $where_type);
    
    $sql = 'UPDATE {' . $table . '} SET ' . implode(', ', $flat_fields) . $where_string;
    
    return $this->runQuery($sql, array_merge($update_values, $where_values), array(), TRUE);
  }

  /**
   * Run a replace query on this database object.
   * 
   * Depending on the database, that could be separate delete/insert queries
   * or a single "insert ... on duplicate update ..." query, or something else.
   * Note that the $where clause must be a simple AND-based equality array, or
   * it will fail.
   *
   * @param $table
   *   The database table on which to run the update query.
   * @param $fields
   *   An associative array of the values to update.  The keys are the
   *   fields, and the corresponding values are the values to update to.
   * @param $where
   *   The where rules for this update query.
   * @param $where_type
   *   Whether to AND or OR the where rules together.
   * @return
   *   A database query result resource, or FALSE if the query was not
   *   executed correctly.
   *
   */
  function replace($table, Array $fields, Array $where) {
    
    // The following trivial method should be replaced with a database-specific
    // mechanism if one exists.
    $num_deleted = $this->delete($table, $where);
    $fields += $where;
    $num_inserted = $this->insert($table, $fields);
    return $num_deleted + $num_inserted;
  }

  /**
   * Run a delete query on this database object.
   *
   * @param $table
   *   The database table on which to run the delete query.
   * @param $where
   *   The where rules for this delete query.
   * @param $where_type
   *   Whether to AND or OR the where rules together.
   * @return
   *   A database query result resource, or FALSE if the query was not
   *   executed correctly.
   *
   */
  function delete($table, Array $where, $where_type = 'AND') {
    list ($where_string, $where_values) = self::where($where, $where_type);
    $sql = 'DELETE FROM {' . $table . '} ' . $where_string;
    return $this->runQuery($sql, $where_values, array(), TRUE);
  }
  
  /**
   * Return the default query options for any given query.
   *
   * @return
   *  An array of default query options.
   */
  static function defaultOptions() {
    return array(
      'target' => 'default',
      'database' => NULL,
      'fetch' => PDO::FETCH_OBJ,
    );
  }

  /**
   * Runs a limited-range query on this database object.
   *
   * Use this as a substitute for ->query() when a subset of the query is to be
   * returned.
   * User-supplied arguments to the query should be passed in as separate parameters
   * so that they can be properly escaped to avoid SQL injection attacks.
   *
   * @param $query
   *   A string containing an SQL query.
   * @param $args
   *  An array of values to substitute into the query at placeholder markers.
   * @param $from
   *   The first result row to return.
   * @param $count
   *   The maximum number of result rows to return.
   * @param $options
   *  An array of options on the query.  This array is assumed to have all
   *  values populated.
   * @return
   *   A database query result resource, or FALSE if the query was not executed
   *   correctly.
   */
   abstract function queryRange($query, Array $args, $from, $count, Array $options);

  /**
   * Runs a SELECT query and stores its results in a temporary table.
   *
   * Use this as a substitute for db_query() when the results need to stored
   * in a temporary table. Temporary tables exist for the duration of the page
   * request.
   * User-supplied arguments to the query should be passed in as separate parameters
   * so that they can be properly escaped to avoid SQL injection attacks.
   *
   * Note that if you need to know how many results were returned, you should do
   * a SELECT COUNT(*) on the temporary table afterwards. db_affected_rows() does
   * not give consistent result across different database types in this case.
   *
   * @param $query
   *   A string containing a normal SELECT SQL query.
   * @param $args
   *  An array of values to substitute into the query at placeholder markers.
   * @param $tablename
   *   The name of the temporary table to select into. This name will not be
   *   prefixed as there is no risk of collision.
   * @return
   *   A database query result resource, or FALSE if the query was not executed
   *   correctly.
   */
   abstract function queryTemporary($query, Array $args, $tablename);

}

class Database_mysql extends Database {
  
  public static $rand = 'RAND()';
  public static $timestamp = 'Y-m-d h:i:s';

  function __construct($url) {
    parent::__construct('mysql:host=' . $url['host'] . ';dbname=' . substr($url['path'], 1), $url['user'], $url['pass'], array(
      PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => TRUE , // So we don't have to mess around with cursors.
      PDO::ATTR_EMULATE_PREPARES => TRUE)// Because MySQL's prepared statements skip the query cache, because it's dumb.
    );
  }

  function queryRange($query, Array $args, $from, $count, Array $options) {
    // Backward compatibility hack, temporary.
    $query = str_replace(array('%d' , '%f' , '%b' , "'%s'"), '?', $query);
    
    return $this->runQuery($query . ' LIMIT ' . $from . ', ' . $count, $args, $options);
  }

  function queryTemporary($query, Array $args, $tablename) {
    $query = preg_replace('/^SELECT/i', 'CREATE TEMPORARY TABLE ' . $tablename . ' Engine=HEAP SELECT', $this->prefixTables($query));
    
    return $this->runQuery($query, $args, $options);
  }

  function replace($table, Array $fields, Array $where) {
    
    $insert_list = $fields + $where;
    
    $insert_fields = array_keys($insert_list);
    $insert_values = array_values($insert_list);
    
    $placeholders = array_fill(0, count($insert_values), '?');
    
    $update_values = array();
    $flat_fields = array();
    
    foreach ($fields as $field => $value) {
      $insert_values[] = $value;
      $flat_fields[] = $field . '=?';
    }
    
    return $this->runQuery('INSERT INTO {' . $table . '} (' . implode(',', $insert_fields) . ') VALUES (' . implode(',', $placeholders) . ') ON DUPLICATE KEY UPDATE ' . implode(', ', $flat_fields), $insert_values, array(), TRUE);
  }
}

/**
 * Not yet functional demo of how one would implement an Oracle or similar driver.
 *
 */
class Database_oci extends Database {

  function __construct($url) {
    parent::__construct('oci:dbname=' . substr($url['path'], 1), $url['user'], $url['pass'], array());
  }

  function insert($table, $fields, $delay = FALSE) {
    $insert_fields = array_keys($fields);
    $insert_values = array_values($fields);
    
    $schema = schema_get_schema($table);
    
    $i = 1;
    foreach ($fields as $field => $value) {
      $type = in_array($schema['fields'][$field]['type'], array('text' , 'blob')) ? PDO::PARAM_LOB : NULL;
      $placeholders[] = in_array($schema['fields'][$field]['type'], array('text' , 'blob')) ? 'EMPTY_BLOB()' : '?';
      $statement->bindParam($i++, $value, $type);
    }
    
    $sql = $this->prefixTables('INSERT INTO {' . $table . '} (' . implode(',', $insert_fields) . ') VALUES (' . implode(',', $placeholders) . ')');
    $statement = $this->prepare($sql);
    
    $statement->beginTransaction();
    $statement->execute();
    $statement->commit();
    
    return $statement;
  }

  function queryRange($query, Array $args, $from, $count, Array $options) {
  
  }

  function queryTemporary($query, Array $args, $tablename) {
  
  }
}

class DBStatement extends PDOStatement {

  public $dbh;

  protected function __construct($dbh) {
    $this->dbh = $dbh;
    $this->setFetchMode(PDO::FETCH_OBJ);
  }

  public function execute($args, $options) {
    if (is_string($options['fetch'])) {
      $this->setFetchMode(PDO::FETCH_CLASS, $options['fetch']);
    }
    else {
      $this->setFetchMode($options['fetch']);
    }
    parent::execute($args);
  }

  public function fetchCol($index = 0) {
    return $this->fetchAll(PDO::FETCH_COLUMN, $index);
  }

  public function fetchAllAssoc($key) {
    $return = array();
    foreach ($this as $record) {
      $return[$record->$key] = $record;
    }
    return $return;
  }

  public function fetchOne($index = 0) {
    return $this->fetchColumn($index);
  }
  
  /**
   * Fetches the next row and returns it as an associative array.
   * 
   * This method corresponds to PDOStatement::fetchObject(),
   * but for associative arrays.  Why objects get a method of their
   * own and arrays do not, I do not know.
   *
   */
  public function fetchAssoc() {
    return $this->fetch(PDO::FETCH_ASSOC);
  }
}

class Dummy { }

/**
 * The following utility functions are simply convenience wrappers.
 * They should never, ever have any database-specific code in them.
 */

function db_query($query, Array $args = array(), Array $options = array()) {
  // Get default options.
  $options += Database::defaultOptions();

  if (isset($options['database'])) {
    return Database::getConnection($options['database'], $options['target'])->query($query, $args, $options);
  }
  return Database::getActiveConnection($options['target'])->query($query, $args, $options);
}

function db_query_range($query, Array $args, $from = 0, $count = 0, Array $options = array()) {
  // Get default options.
  $options += Database::defaultOptions();

  if (isset($options['database'])) {
    return Database::getConnection($options['database'], $options['target'])->queryRange($query, $args, $from, $count, $options);
  }
  return Database::getActiveConnection($options['target'])->queryRange($query, $args, $from, $count, $options);
}

function db_query_temporary($query, Array $args, $tablename) {
  return Database::getActiveConnection()->queryTemporary($query, $args, $tablename);
}

function db_insert($table, Array $fields = array(), $delay = FALSE) {
  return Database::getActiveConnection()->insert($table, $fields, $delay);
}

function db_update($table, Array $fields = array(), $where = array(), $where_type = 'AND', $delay = FALSE) {
  return Database::getActiveConnection()->update($table, $fields, $where, $where_type, $delay);
}

function db_replace($table, Array $fields = array(), $where = array()) {
  return Database::getActiveConnection()->replace($table, $fields, $where);
}

function db_delete($table, Array $where = array(), $where_type = 'AND', $delay = FALSE) {
  return Database::getActiveConnection()->delete($table, $where, $where_type, $delay);
}

function db_set_active($key = 'default') {
  Database::setActiveConnection($key);
}

// For temporary backward compatibility only.
function db_fetch_object(DBStatement $statement) {
  return $statement->fetch(PDO::FETCH_OBJ);
}

function db_fetch_array(DBStatement $statement) {
  return $statement->fetch(PDO::FETCH_BOTH);
}

/**
 * Some testing and demo code.
 */

/**
 * The $db_url array, which defines our various and sundry connections.
 */
$db_url['default']['default'] = 'mysql://test:test@localhost/drupal6test';
$db_url['default']['slave'][] = 'mysql://test:test@localhost/drupal6test';
$db_url['default']['slave'][] = 'mysql://test:test@localhost/drupal6test';
$db_url['default']['slave'][] = 'mysql://test:test@localhost/drupal6test';


db_query("SELECT * FROM {system} WHERE status=:status", array(':status' => 1), array('target' => 'slave', 'fetch' => 'Dummy'));


$result = db_query("SELECT * FROM {system} WHERE status=:status", array(':status' => 1));
foreach ($result as $record) {
  //debug($record);
}

$result2 = db_query("SELECT * FROM {system} WHERE status=:status", array(':status' => 1), array('target' => 'slave'));
//debug($result2->fetchAll());

$result3 = db_query("SELECT * FROM {system} WHERE status='%s'", array(1));
//debug($result3->fetchAll());


db_query("DROP TABLE IF EXISTS {test}");
db_query("CREATE TABLE {test} (
id INT AUTO_INCREMENT NOT NULL,
name VARCHAR(255) NOT NULL DEFAULT '',
age INT NOT NULL DEFAULT 0,
PRIMARY KEY (id)
);");

db_insert('test', array('name' => 'Larry' , 'age' => 26), TRUE);
debug(db_insert('test', array('name' => 'George' , 'age' => 28)));
db_insert('test', array('name' => 'Dan' , 'age' => 24));
db_insert('test', array('name' => 'Robert' , 'age' => 22));
db_insert('test', array('name' => 'Bill' , 'age' => 20));

debug(db_query("SELECT * FROM {test}")->fetchAll());

debug(db_delete('test', array('age' => 24)));

debug(db_query("SELECT * FROM {test}")->fetchAll());

$fields['name'] = 'Jimmy';
$where = array(
  'name' => 'Larry', 
  'not' => array('age' => 26), 
  'or' => array('age' => 20)
);

debug(db_update('test', $fields, $where));

$where = array('<' => array('age' => 26));
debug(db_update('test', $fields, $where));

debug(db_query_range("SELECT * FROM {test} WHERE age >= ? ORDER BY age", array(20), 0, 3)->fetchAll());

//db_query_temporary("SELECT * FROM {test} WHERE age >= ? ORDER BY age", array(24), 'temp');
//debug(db_query("SHOW TABLES")->fetchAll());
//debug(db_query("SELECT * from temp"));


$fields = array('name' => 'Jimmy' , 'age' => 21);
$where = array('id' => 1);
db_replace('test', $fields, $where);

debug(db_query("SELECT * FROM {test}")->fetchAll());

debug(db_query_range("SELECT * FROM {test} WHERE age >= ? ORDER BY age", array(20), 0, 3));

$where = array('name' => 'Larry' , 'not' => array('age' => 26) , 'or' => array('age' => 20 , 'name' => 'Bob') , '<' => array('age' => 26) , 'name' => array('John' , 'Paul' , 'George' , 'Ringo') , 'NOT' => array('or' => array('age' => 24 , 'name' => 'George' , '>=' => array('age' => 20))));

debug(db_query("SELECT * FROM {system} WHERE name='user'")->fetchOne());

debug(db_query("SELECT * FROM {system} WHERE type='module'")->fetchAssoc('name'));