Query/core/query_builder.php

1049 lines
23 KiB
PHP
Raw Normal View History

2012-03-15 09:25:18 -04:00
<?php
/**
* Query
*
* Free Query Builder / Database Abstraction Layer
*
2012-04-23 13:28:49 -04:00
* @package Query
* @author Timothy J. Warren
2014-01-02 12:36:50 -05:00
* @copyright Copyright (c) 2012 - 2014
2012-03-15 09:25:18 -04:00
* @link https://github.com/aviat4ion/Query
2012-04-23 13:28:49 -04:00
* @license http://philsturgeon.co.uk/code/dbad-license
2012-03-15 09:25:18 -04:00
*/
// --------------------------------------------------------------------------
2014-04-02 17:08:50 -04:00
namespace Query;
use Query\Driver\Driver_Interface;
2014-04-07 18:28:53 -04:00
2014-04-24 17:07:50 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
2014-04-22 14:02:54 -04:00
* Convenience class for creating sql queries - also the class that
2012-03-15 09:25:18 -04:00
* instantiates the specific db driver
2012-04-20 13:17:39 -04:00
*
* @package Query
2014-03-31 16:01:58 -04:00
* @subpackage Query_Builder
2012-03-15 09:25:18 -04:00
*/
class Query_Builder extends Abstract_Query_Builder implements Query_Builder_Interface {
// --------------------------------------------------------------------------
// ! SQL Clause Strings
// --------------------------------------------------------------------------
/**
* Compiled 'select' clause
* @var string
*/
protected $select_string = '';
/**
* Compiled 'from' clause
* @var string
*/
protected $from_string;
/**
* Compiled arguments for insert / update
* @var string
*/
protected $set_string;
/**
* Order by clause
* @var string
*/
protected $order_string;
/**
* Group by clause
* @var string
*/
protected $group_string;
// --------------------------------------------------------------------------
// ! SQL Clause Arrays
// --------------------------------------------------------------------------
/**
* Keys for insert/update statement
* @var array
*/
protected $set_array_keys = array();
/**
* Key/val pairs for order by clause
* @var array
*/
protected $order_array = array();
/**
* Key/val pairs for group by clause
* @var array
*/
protected $group_array = array();
// --------------------------------------------------------------------------
// ! Other Class vars
// --------------------------------------------------------------------------
/**
* Values to apply to prepared statements
* @var array
*/
protected $values = array();
/**
* Values to apply to where clauses in prepared statements
* @var array
*/
protected $where_values = array();
/**
* Value for limit string
* @var string
*/
protected $limit;
/**
* Value for offset in limit string
* @var int
*/
protected $offset;
/**
* Query component order mapping
* for complex select queries
*
* Format:
* array(
* 'type' => 'where',
* 'conjunction' => ' AND ',
* 'string' => 'k=?'
* )
*
* @var array
*/
protected $query_map = array();
/**
* Map for having clause
* @var array
*/
protected $having_map;
/**
* Convenience property for connection management
* @var string
*/
public $conn_name = "";
/**
* List of queries executed
* @var array
*/
public $queries;
/**
* Whether to do only an explain on the query
* @var bool
*/
protected $explain;
/**
* The current database driver
* @var Driver_Interface
*/
public $db;
/**
* Query parser class instance
* @var Query_Parser
*/
protected $parser;
/**
* Alias to driver util class
* @var \Query\Driver\Abstract_Util
*/
public $util;
/**
* Alias to driver sql class
* @var \Query\Driver\SQL_Interface
*/
public $sql;
2014-04-24 21:29:40 -04:00
/**
* String class values to be reset
*
* @var array
*/
private $string_vars = array(
'select_string',
'from_string',
'set_string',
'order_string',
'group_string',
'limit',
'offset',
'explain',
);
/**
* Array class variables to be reset
*
* @var array
*/
private $array_vars = array(
'set_array_keys',
'order_array',
'group_array',
'values',
'where_values',
'query_map',
'having_map'
);
// --------------------------------------------------------------------------
// ! Methods
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Constructor
*
2014-04-02 17:08:50 -04:00
* @param \Query\Driver\Driver_Interface $db
* @param Query_Parser $parser
2012-03-15 09:25:18 -04:00
*/
public function __construct(Driver_Interface $db, Query_Parser $parser)
2012-03-15 09:25:18 -04:00
{
// Inject driver and parser
$this->db = $db;
$this->parser = $parser;
2012-10-31 16:21:15 -04:00
2013-02-28 12:22:55 -05:00
$this->queries['total_time'] = 0;
// Alias driver sql and util classes
$this->sql = $this->db->get_sql();
$this->util = $this->db->get_util();
2012-10-31 16:21:15 -04:00
}
2014-02-21 15:08:00 -05:00
2014-02-17 20:10:47 -05:00
// --------------------------------------------------------------------------
2014-02-21 15:08:00 -05:00
2014-02-17 20:10:47 -05:00
/**
* Destructor
* @codeCoverageIgnore
2014-02-17 20:10:47 -05:00
*/
public function __destruct()
{
$this->db = NULL;
}
// --------------------------------------------------------------------------
/**
* Calls a function further down the inheritence chain
*
* @param string $name
* @param array $params
* @return mixed
* @throws \BadMethodCallException
*/
public function __call($name, $params)
{
// Allow camel-case method calls
$snake_name = \from_camel_case($name);
foreach(array($this, $this->db) as $object)
{
foreach(array($name, $snake_name) as $method_name)
{
if (method_exists($object, $method_name))
{
return call_user_func_array(array($object, $method_name), $params);
}
}
}
throw new \BadMethodCallException("Method does not exist");
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
// ! Select Queries
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Specifies rows to select in a query
*
* @param string $fields
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function select($fields)
{
// Split fields by comma
$fields_array = explode(",", $fields);
2012-11-07 08:42:34 -05:00
$fields_array = array_map('mb_trim', $fields_array);
2012-03-15 09:25:18 -04:00
// Split on 'As'
foreach ($fields_array as $key => $field)
2012-03-15 09:25:18 -04:00
{
if (stripos($field, 'as') !== FALSE)
{
$fields_array[$key] = preg_split('` as `i', $field);
2012-11-07 08:42:34 -05:00
$fields_array[$key] = array_map('mb_trim', $fields_array[$key]);
2012-03-15 09:25:18 -04:00
}
}
// Quote the identifiers
$safe_array = $this->db->quote_ident($fields_array);
2012-03-15 09:25:18 -04:00
unset($fields_array);
// Join the strings back together
for($i = 0, $c = count($safe_array); $i < $c; $i++)
{
if (is_array($safe_array[$i]))
{
$safe_array[$i] = implode(' AS ', $safe_array[$i]);
}
}
2014-02-14 10:38:25 -05:00
$this->select_string .= implode(', ', $safe_array);
2012-03-15 09:25:18 -04:00
unset($safe_array);
return $this;
}
2012-08-09 12:15:36 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
2012-04-30 15:29:45 -04:00
/**
* Selects the maximum value of a field from a query
*
* @param string $field
2014-04-22 14:02:54 -04:00
* @param string|FALSE $as
* @return Query_Builder
2012-04-30 15:29:45 -04:00
*/
public function select_max($field, $as=FALSE)
{
// Create the select string
2012-10-31 16:21:15 -04:00
$this->select_string .= ' MAX'.$this->_select($field, $as);
return $this;
}
2012-08-09 12:15:36 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
/**
* Selects the minimum value of a field from a query
*
* @param string $field
* @param string|bool $as
* @return Query_Builder
*/
public function select_min($field, $as=FALSE)
2012-08-09 12:15:36 -04:00
{
// Create the select string
2012-10-31 16:21:15 -04:00
$this->select_string .= ' MIN'.$this->_select($field, $as);
return $this;
}
2012-08-09 12:15:36 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
/**
* Selects the average value of a field from a query
*
* @param string $field
* @param string|bool $as
* @return Query_Builder
*/
public function select_avg($field, $as=FALSE)
{
// Create the select string
2012-10-31 16:21:15 -04:00
$this->select_string .= ' AVG'.$this->_select($field, $as);
return $this;
}
2012-08-09 12:15:36 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
/**
* Selects the sum of a field from a query
*
* @param string $field
* @param string|bool $as
* @return Query_Builder
*/
public function select_sum($field, $as=FALSE)
{
// Create the select string
2012-10-31 16:21:15 -04:00
$this->select_string .= ' SUM'.$this->_select($field, $as);
return $this;
}
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
/**
* Adds the 'distinct' keyword to a query
*
* @return Query_Builder
*/
public function distinct()
{
// Prepend the keyword to the select string
2012-10-31 16:21:15 -04:00
$this->select_string = ' DISTINCT '.$this->select_string;
return $this;
}
2014-02-21 15:08:00 -05:00
2014-02-04 20:59:30 -05:00
// --------------------------------------------------------------------------
2014-02-21 15:08:00 -05:00
2014-02-04 20:59:30 -05:00
/**
* Tell the database to give you the query plan instead of result set
*
* @return Query_Builder
2014-02-04 20:59:30 -05:00
*/
public function explain()
{
$this->explain = TRUE;
return $this;
}
2012-08-09 12:15:36 -04:00
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Specify the database table to select from
*
2012-11-07 08:42:34 -05:00
* @param string $tblname
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
2012-11-07 08:42:34 -05:00
public function from($tblname)
2012-03-15 09:25:18 -04:00
{
// Split identifiers on spaces
$ident_array = explode(' ', \mb_trim($tblname));
$ident_array = array_map('\\mb_trim', $ident_array);
// Quote the identifiers
2012-11-07 08:42:34 -05:00
$ident_array[0] = $this->db->quote_table($ident_array[0]);
$ident_array = $this->db->quote_ident($ident_array);
2012-03-15 09:25:18 -04:00
// Paste it back together
$this->from_string = implode(' ', $ident_array);
2012-03-15 09:25:18 -04:00
return $this;
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
// ! 'Like' methods
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
/**
* Creates a Like clause in the sql statement
*
* @param string $field
* @param mixed $val
* @param string $pos
* @return Query_Builder
*/
2012-04-30 16:06:06 -04:00
public function like($field, $val, $pos='both')
{
2012-05-01 13:45:11 -04:00
return $this->_like($field, $val, $pos, 'LIKE', 'AND');
2012-03-15 09:25:18 -04:00
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Generates an OR Like clause
*
* @param string $field
* @param mixed $val
* @param string $pos
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function or_like($field, $val, $pos='both')
{
2012-05-01 13:45:11 -04:00
return $this->_like($field, $val, $pos, 'LIKE', 'OR');
2012-03-15 09:25:18 -04:00
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Generates a NOT LIKE clause
*
* @param string $field
* @param mixed $val
* @param string $pos
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function not_like($field, $val, $pos='both')
{
2012-05-01 13:45:11 -04:00
return $this->_like($field, $val, $pos, 'NOT LIKE', 'AND');
2012-03-15 09:25:18 -04:00
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Generates a OR NOT LIKE clause
*
* @param string $field
* @param mixed $val
* @param string $pos
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function or_not_like($field, $val, $pos='both')
{
2012-05-01 13:45:11 -04:00
return $this->_like($field, $val, $pos, 'NOT LIKE', 'OR');
2012-03-15 09:25:18 -04:00
}
2012-08-09 12:15:36 -04:00
2012-05-01 13:45:11 -04:00
// --------------------------------------------------------------------------
// ! Having methods
2012-04-16 13:43:41 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
/**
* Generates a 'Having' clause
*
* @param mixed $key
* @param mixed $val
* @return Query_Builder
*/
2012-05-01 13:45:11 -04:00
public function having($key, $val=array())
{
return $this->_having($key, $val, 'AND');
}
2012-08-09 12:15:36 -04:00
2012-05-01 13:45:11 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
2012-04-16 13:43:41 -04:00
/**
* Generates a 'Having' clause prefixed with 'OR'
*
* @param mixed $key
* @param mixed $val
* @return Query_Builder
2012-04-16 13:43:41 -04:00
*/
public function or_having($key, $val=array())
{
2012-05-01 13:45:11 -04:00
return $this->_having($key, $val, 'OR');
2012-04-16 13:43:41 -04:00
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
// ! 'Where' methods
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Specify condition(s) in the where clause of a query
* Note: this function works with key / value, or a
2012-03-15 09:25:18 -04:00
* passed array with key / value pairs
*
* @param mixed $key
2012-03-15 09:25:18 -04:00
* @param mixed $val
2014-02-04 20:59:30 -05:00
* @param mixed $escape
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
2014-02-04 20:59:30 -05:00
public function where($key, $val=array(), $escape=NULL)
2012-03-15 09:25:18 -04:00
{
2012-05-01 13:45:11 -04:00
return $this->_where_string($key, $val, 'AND');
2012-03-15 09:25:18 -04:00
}
// --------------------------------------------------------------------------
/**
* Where clause prefixed with "OR"
*
2012-05-01 13:45:11 -04:00
* @param string $key
2012-03-15 09:25:18 -04:00
* @param mixed $val
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
2012-05-01 13:45:11 -04:00
public function or_where($key, $val=array())
2012-03-15 09:25:18 -04:00
{
2012-05-01 13:45:11 -04:00
return $this->_where_string($key, $val, 'OR');
2012-03-15 09:25:18 -04:00
}
// --------------------------------------------------------------------------
/**
* Where clause with 'IN' statement
*
* @param mixed $field
* @param mixed $val
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function where_in($field, $val=array())
{
2012-05-01 13:45:11 -04:00
return $this->_where_in($field, $val);
2012-03-15 09:25:18 -04:00
}
// --------------------------------------------------------------------------
/**
* Where in statement prefixed with "or"
*
* @param string $field
* @param mixed $val
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function or_where_in($field, $val=array())
{
2012-05-01 13:45:11 -04:00
return $this->_where_in($field, $val, 'IN', 'OR');
2012-03-15 09:25:18 -04:00
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
/**
* WHERE NOT IN (FOO) clause
*
* @param string $field
* @param mixed $val
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function where_not_in($field, $val=array())
{
2012-05-01 13:45:11 -04:00
return $this->_where_in($field, $val, 'NOT IN', 'AND');
2012-03-15 09:25:18 -04:00
}
// --------------------------------------------------------------------------
/**
* OR WHERE NOT IN (FOO) clause
*
2012-03-15 09:25:18 -04:00
* @param string $field
* @param mixed $val
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function or_where_not_in($field, $val=array())
{
2012-05-01 13:45:11 -04:00
return $this->_where_in($field, $val, 'NOT IN', 'OR');
2012-03-15 09:25:18 -04:00
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
// ! Other Query Modifier methods
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
2012-04-16 13:43:41 -04:00
/**
* Sets values for inserts / updates / deletes
*
* @param mixed $key
* @param mixed $val
* @return Query_Builder
2012-04-16 13:43:41 -04:00
*/
2012-04-30 14:49:30 -04:00
public function set($key, $val = NULL)
2012-04-16 13:43:41 -04:00
{
2014-04-28 16:41:46 -04:00
$this->_mixed_set($this->set_array_keys, $key, $val, self::KEY);
$this->_mixed_set($this->values, $key, $val, self::VALUE);
2012-04-16 13:43:41 -04:00
// Use the keys of the array to make the insert/update string
// Escape the field names
2014-02-14 22:08:19 -05:00
$this->set_array_keys = array_map(array($this->db, '_quote'), $this->set_array_keys);
2012-04-16 13:43:41 -04:00
// Generate the "set" string
$this->set_string = implode('=?,', $this->set_array_keys);
2012-04-16 13:43:41 -04:00
$this->set_string .= '=?';
return $this;
}
2012-08-09 12:15:36 -04:00
2012-04-16 13:43:41 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Creates a join phrase in a compiled query
*
* @param string $table
* @param string $condition
* @param string $type
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function join($table, $condition, $type='')
{
2012-11-07 08:42:34 -05:00
// Prefix and quote table name
$table = explode(' ', mb_trim($table));
$table[0] = $this->db->quote_table($table[0]);
$table = $this->db->quote_ident($table);
$table = implode(' ', $table);
2012-08-09 12:15:36 -04:00
// Parse out the join condition
2014-04-02 17:08:50 -04:00
$parsed_condition = $this->parser->compile_join($condition);
2012-08-09 12:15:36 -04:00
$condition = $table . ' ON ' . $parsed_condition;
$this->_append_map("\n" . strtoupper($type) . ' JOIN ', $condition, 'join');
2012-03-15 09:25:18 -04:00
return $this;
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Group the results by the selected field(s)
*
* @param mixed $field
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function group_by($field)
{
if ( ! is_scalar($field))
{
$new_group_array = array_map(array($this->db, 'quote_ident'), $field);
$this->group_array = array_merge($this->group_array, $new_group_array);
2012-03-15 09:25:18 -04:00
}
else
{
$this->group_array[] = $this->db->quote_ident($field);
2012-03-15 09:25:18 -04:00
}
$this->group_string = ' GROUP BY ' . implode(',', $this->group_array);
2012-03-15 09:25:18 -04:00
return $this;
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Order the results by the selected field(s)
*
* @param string $field
* @param string $type
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function order_by($field, $type="")
{
// When ordering by random, do an ascending order if the driver
// doesn't support random ordering
2012-03-15 09:25:18 -04:00
if (stripos($type, 'rand') !== FALSE)
{
$rand = $this->sql->random();
$type = ($rand !== FALSE) ? $rand : 'ASC';
2012-03-15 09:25:18 -04:00
}
2012-03-15 09:25:18 -04:00
// Set fields for later manipulation
$field = $this->db->quote_ident($field);
2012-03-15 09:25:18 -04:00
$this->order_array[$field] = $type;
2012-03-15 09:25:18 -04:00
$order_clauses = array();
2012-03-15 09:25:18 -04:00
// Flatten key/val pairs into an array of space-separated pairs
foreach($this->order_array as $k => $v)
2012-03-15 09:25:18 -04:00
{
$order_clauses[] = $k . ' ' . strtoupper($v);
}
2012-03-15 09:25:18 -04:00
// Set the final string
$this->order_string = ( ! isset($rand))
2014-02-14 10:38:25 -05:00
? "\nORDER BY ".implode(', ', $order_clauses)
: "\nORDER BY".$rand;
2012-03-15 09:25:18 -04:00
return $this;
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Set a limit on the current sql statement
*
* @param int $limit
2014-04-22 14:02:54 -04:00
* @param int|bool $offset
* @return Query_Builder
2012-03-15 09:25:18 -04:00
*/
public function limit($limit, $offset=FALSE)
{
$this->limit = $limit;
$this->offset = $offset;
2012-03-15 09:25:18 -04:00
return $this;
}
// --------------------------------------------------------------------------
// ! Query Grouping Methods
// --------------------------------------------------------------------------
/**
* Adds a paren to the current query for query grouping
*
* @return Query_Builder
*/
public function group_start()
{
$conj = (empty($this->query_map)) ? ' WHERE ' : ' ';
$this->_append_map($conj, '(', 'group_start');
return $this;
}
// --------------------------------------------------------------------------
/**
* Adds a paren to the current query for query grouping,
* prefixed with 'OR'
*
* @return Query_Builder
*/
public function or_group_start()
{
$this->_append_map('', ' OR (', 'group_start');
return $this;
}
// --------------------------------------------------------------------------
/**
* Adds a paren to the current query for query grouping,
* prefixed with 'OR NOT'
*
* @return Query_Builder
*/
public function or_not_group_start()
{
$this->_append_map('', ' OR NOT (', 'group_start');
return $this;
}
// --------------------------------------------------------------------------
/**
* Ends a query group
*
* @return Query_Builder
*/
public function group_end()
{
$this->_append_map('', ')', 'group_end');
return $this;
}
2012-08-09 12:15:36 -04:00
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
// ! Query execution methods
// --------------------------------------------------------------------------
2012-03-15 09:25:18 -04:00
/**
* Select and retrieve all records from the current table, and/or
* execute current compiled query
*
* @param $table
2014-04-22 14:02:54 -04:00
* @param int|bool $limit
* @param int|bool $offset
* @return \PDOStatement
2012-03-15 09:25:18 -04:00
*/
public function get($table='', $limit=FALSE, $offset=FALSE)
{
// Set the table
2014-04-24 21:29:40 -04:00
if ( ! empty($table)) $this->from($table);
2012-03-15 09:25:18 -04:00
// Set the limit, if it exists
2014-04-24 21:29:40 -04:00
if (is_int($limit)) $this->limit($limit, $offset);
return $this->_run("get", $table);
2012-03-15 09:25:18 -04:00
}
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
/**
* Convenience method for get() with a where clause
*
* @param string $table
* @param array $where
* @param int|bool $limit
* @param int|bool $offset
* @return \PDOStatement
*/
public function get_where($table, $where=array(), $limit=FALSE, $offset=FALSE)
{
// Create the where clause
$this->where($where);
2012-08-09 12:15:36 -04:00
// Return the result
return $this->get($table, $limit, $offset);
}
2012-08-09 12:15:36 -04:00
2012-04-16 13:43:41 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
2012-04-16 13:43:41 -04:00
/**
* Retreive the number of rows in the selected table
*
* @param string $table
* @return int
*/
public function count_all($table)
{
$sql = 'SELECT * FROM '.$this->db->quote_table($table);
$res = $this->db->query($sql);
return (int) count($res->fetchAll());
2012-04-16 13:43:41 -04:00
}
2012-08-09 12:15:36 -04:00
2012-04-16 13:43:41 -04:00
// --------------------------------------------------------------------------
2012-08-09 12:15:36 -04:00
2012-04-16 13:43:41 -04:00
/**
* Retrieve the number of results for the generated query - used
* in place of the get() method
*
* @param string $table
* @return int
*/
public function count_all_results($table='')
{
// Set the table
2014-04-24 21:29:40 -04:00
if ( ! empty($table)) $this->from($table);
2012-08-09 12:15:36 -04:00
$result = $this->_run('get', $table);
$rows = $result->fetchAll();
2012-08-09 12:15:36 -04:00
2012-04-17 11:43:06 -04:00
return (int) count($rows);
2012-04-16 13:43:41 -04:00
}
2012-08-09 12:15:36 -04:00
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
/**
* Creates an insert clause, and executes it
*
* @param string $table
* @param mixed $data
* @return \PDOStatement
2012-03-15 09:25:18 -04:00
*/
public function insert($table, $data=array())
{
// No use duplicating logic!
2014-04-24 21:29:40 -04:00
if ( ! empty($data)) $this->set($data);
return $this->_run("insert", $table);
2012-03-15 09:25:18 -04:00
}
2014-02-21 15:08:00 -05:00
// --------------------------------------------------------------------------
2014-02-21 15:08:00 -05:00
/**
2014-03-31 16:01:58 -04:00
* Creates and executes a batch insertion query
*
* @param string $table
* @param array $data
* @return \PDOStatement
*/
public function insert_batch($table, $data=array())
{
// Get the generated values and sql string
list($sql, $data) = $this->db->insert_batch($table, $data);
2014-02-21 15:08:00 -05:00
return ( ! is_null($sql))
? $this->_run('', $table, $sql, $data)
: NULL;
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
/**
* Creates an update clause, and executes it
*
* @param string $table
* @param mixed $data
* @return \PDOStatement
2012-03-15 09:25:18 -04:00
*/
public function update($table, $data=array())
{
// No use duplicating logic!
2014-04-24 21:29:40 -04:00
if ( ! empty($data)) $this->set($data);
return $this->_run("update", $table);
2012-03-15 09:25:18 -04:00
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
/**
* Deletes data from a table
*
* @param string $table
* @param mixed $where
* @return \PDOStatement
2012-03-15 09:25:18 -04:00
*/
public function delete($table, $where='')
{
// Set the where clause
2014-04-24 21:29:40 -04:00
if ( ! empty($where)) $this->where($where);
2012-03-15 09:25:18 -04:00
return $this->_run("delete", $table);
2012-03-15 09:25:18 -04:00
}
// --------------------------------------------------------------------------
2012-12-18 16:19:52 -05:00
// ! SQL Returning Methods
// --------------------------------------------------------------------------
/**
* Returns the generated 'select' sql query
*
* @param string $table
* @param bool $reset
* @return string
*/
public function get_compiled_select($table='', $reset=TRUE)
{
// Set the table
2014-04-24 21:29:40 -04:00
if ( ! empty($table)) $this->from($table);
return $this->_get_compile('select', $table, $reset);
}
// --------------------------------------------------------------------------
/**
* Returns the generated 'insert' sql query
*
* @param string $table
* @param bool $reset
* @return string
*/
public function get_compiled_insert($table, $reset=TRUE)
{
return $this->_get_compile('insert', $table, $reset);
}
// --------------------------------------------------------------------------
/**
2012-12-18 16:19:52 -05:00
* Returns the generated 'update' sql query
*
* @param string $table
* @param bool $reset
* @return string
*/
public function get_compiled_update($table='', $reset=TRUE)
{
return $this->_get_compile('update', $table, $reset);
}
// --------------------------------------------------------------------------
/**
2012-12-18 16:19:52 -05:00
* Returns the generated 'delete' sql query
*
* @param string $table
* @param bool $reset
* @return string
*/
public function get_compiled_delete($table="", $reset=TRUE)
{
return $this->_get_compile('delete', $table, $reset);
}
2012-03-15 09:25:18 -04:00
// --------------------------------------------------------------------------
// ! Miscellaneous Methods
// --------------------------------------------------------------------------
/**
* Clear out the class variables, so the next query can be run
*
* @return void
2012-03-15 09:25:18 -04:00
*/
public function reset_query()
2012-03-15 09:25:18 -04:00
{
2014-04-02 15:11:46 -04:00
// Reset strings and booleans
2014-04-24 21:29:40 -04:00
foreach($this->string_vars as $var)
2014-04-02 15:11:46 -04:00
{
$this->$var = NULL;
}
2014-04-02 15:11:46 -04:00
// Reset arrays
2014-04-24 21:29:40 -04:00
foreach($this->array_vars as $var)
{
$this->$var = array();
2012-03-15 09:25:18 -04:00
}
}
}
2014-02-04 20:59:30 -05:00
// End of query_builder.php