WebSVN - PHPX - Diff - Rev 52 and 56



 */
class Table extends \PointedEars\PHPX\AbstractModel
{
  /**
   * Name of the table
   * @var string
   */
  protected static $_name = '';

  /**
   * Database of the table
   * @var Database|string
   */
  protected static $_database;

  /**
   * Name of the primary key column of the table
   * @var string
   */
  protected static $_id = 'id';

  /**
   * Creates a new <code>Table</code> instance.
   *
   * Each of the parameters is optional and can also be given

   *   Table name
   * @param string $id
   *   Name of the primary key column
   * @throws InvalidArgumentException
   */
  public function __construct ($database = null, $name = '', $id = '')
  {
    if ($database === null)
    {
                /* Call getter to convert to Database if possible */
        if ($this->database === null)
        {
                $this->database = Application::getInstance()->getDefaultDatabase();
        }
    }
    else
    {
      $this->database = $database;
    }

    if ($name !== '')
    {
      $this->name = $name;
    }

    $name = $this->name;
    if (!\is_string($name))
    {
      throw new \InvalidArgumentException(
        'Expected string for table name, saw '
                                . (\is_object($name) ? \get_class($name) : \gettype($name)));
    }

    if ($id !== '')
    {
      $this->id = $id;
    }
  }

  /**
   * @param string $value
   */
  public function setName ($value)
  {
        $class = \get_class($this);
        $class::$_name = (string) $value;
  }

  /**
   * @return string
   */
  public function getName ()
  {
        $class = \get_class($this);
        return $class::$_name;
  }

  /**
   * Returns the database for the table
   * @return Database
   */
  public function getDatabase()
  {
        $class = \get_class($this);
    if (\is_string($class::$_database))
    {
      /* Call setter to convert to Database */
      $this->setDatabase($class::$_database);
    }

    return $class::$_database;
  }

  /**
   * @param Database|string $value
   * @throws InvalidArgumentException
   */
  public function setDatabase ($value)
  {
        $class = \get_class($this);
        if ($value instanceof Database)
        {
                $class::$_database = $value;
        }
        else if ($value !== null)
        {
                $database = new $value();
                if (!($database instanceof Database))
                {
                        throw new \InvalidArgumentException(
                                'Expected Database instance or string for class name, saw '
                                        . (\is_object($value) ? \get_class($value) : \gettype($value))
                        );
                }

                $class::$_database = $database;
        }
  }

  /**
   * @param string $value
   */
  public function setId ($value)
  {
        $class = \get_class($this);
        $class::$_id = (string) $value;
  }

  /**
   * @return string
   */
  public function getId ()
  {
        $class = \get_class($this);
        return $class::$_id;
  }

  /**
   * Initiates a transaction
   *
   * @return bool
   * @see Database::beginTransaction()
   */
  public function beginTransaction()
  {
    return $this->database->beginTransaction();
  }

  /**
   * Rolls back a transaction
   *
   * @return bool
   * @see Database::rollBack()
   */
  public function rollBack()
  {
    return $this->database->rollBack();
  }

  /**
   * Commits a transaction
   *
   * @return bool
   * @see Database::commit()
   */
  public function commit()
  {
    return $this->database->commit();
  }

  /**
   * Retrieves all rows from the table
   *
   * @return array
   * @see Database::fetchAll()
   */
  public function fetchAll($fetch_style = null, $column_index = null, array $ctor_args = null)
  {
    return $this->database->fetchAll($this->name, $fetch_style, $column_index, $ctor_args);
  }

  /**
   * Selects data from one or more tables
   *
   * @return array
   * @see Database::select()
   */
  public function select($columns = null, $where = null, $order = null, $limit = null)
  {
    return $this->database->select($this->name, $columns, $where, $order, $limit);
  }

  /**
   * Updates records in one or more tables
   *
   * @return bool
   * @see Database::update()
   */
  public function update($data, $condition)
  {
    return $this->database->update($this->name, $data, $condition);
  }

  /**
   * Inserts a record into the table
   *
   * @return bool
   * @see Database::insert()
   */
  public function insert($data, $cols = null)
  {
    return $this->database->insert($this->name, $data, $cols);
  }

  /**
   * Returns the ID of the last inserted row, or the last value from
   * a sequence object, depending on the underlying driver.

   * @return int
   * @see Database::getLastInsertId()
   */
  public function getLastInsertId()
  {
    return $this->database->lastInsertId;
  }

  /**
   * Delete a record from the table
   *

   */
  public function delete ($id, array $condition = null)
  {
    if ($id !== null)
    {
      $condition = array($this->id => $id);
    }
    else if ($condition === null)
    {
      throw new InvalidArgumentException(
        '$id and $condition cannot both be null');
    }

    return $this->database->delete($this->name, $condition);
  }

 /**
  * Inserts a row into the table or updates an existing one
  *

  * @see Table::update()
  * @see Table::insert()
  */
  public function updateOrInsert($data, array $condition = null)
  {
    if ($this->select($this->id, $condition))
    {
      return $this->update($data, $condition);
    }

        return $this->insert($data);

    if (defined('DEBUG') && DEBUG > 0)
    {
      debug($id);
    }

    $result = $this->select(null, array($this->id => $id));

    if ($result)
    {
      $result = $result[0];
    }

Rev 52	Rev 56
Line 15...	Line 15...
15	*/	15	*/
16	class Table extends \PointedEars\PHPX\AbstractModel	16	class Table extends \PointedEars\PHPX\AbstractModel
17	{	17	{
18	/**	18	/**
19	* Name of the table	19	* Name of the table
-		20	* @var string
20	*/	21	*/
21	protected $_name = '';	22	protected static $_name = '';
22		23
23	/**	24	/**
24	* Database of the table	25	* Database of the table
25	* @var Database\|string	26	* @var Database\|string
26	*/	27	*/
27	protected $_database;	28	protected static $_database;
28		29
-		30	/**
-		31	* Name of the primary key column of the table
-		32	* @var string
-		33	*/
29	protected $_id = 'id';	34	protected static $_id = 'id';
30		35
31	/**	36	/**
32	* Creates a new <code>Table</code> instance.	37	* Creates a new <code>Table</code> instance.
33	*	38	*
34	* Each of the parameters is optional and can also be given	39	* Each of the parameters is optional and can also be given
Line 45...	Line 50...
45	* Table name	50	* Table name
46	* @param string $id	51	* @param string $id
47	* Name of the primary key column	52	* Name of the primary key column
48	* @throws InvalidArgumentException	53	* @throws InvalidArgumentException
49	*/	54	*/
50	public function __construct($database = null, $name = '', $id = '')	55	public function __construct ($database = null, $name = '', $id = '')
51	{	56	{
52	if ($database === null)	57	if ($database === null)
53	{	58	{
54	/* Call getter to convert to Database if possible */	59	/* Call getter to convert to Database if possible */
55	if ($this->database === null)	60	if ($this->database === null)
56	{	61	{
57	$this->_database = Application::getInstance()->getDefaultDatabase();	62	$this->database = Application::getInstance()->getDefaultDatabase();
58	}	63	}
59	}	64	}
60	else	65	else
61	{	66	{
62	$this->_database = $database;	67	$this->database = $database;
63	}	68	}
64		69
65	if ($name !== '')	70	if ($name !== '')
66	{	71	{
67	$this->_name = $name;	72	$this->name = $name;
68	}	73	}
69		74
-		75	$name = $this->name;
70	if (!\is_string($this->_name))	76	if (!\is_string($name))
71	{	77	{
72	throw new \InvalidArgumentException(	78	throw new \InvalidArgumentException(
73	'Expected string for table name, saw '	79	'Expected string for table name, saw '
74	. \get_class($this->_name) \|\| \gettype($this->_name));	80	. (\is_object($name) ? \get_class($name) : \gettype($name)));
75	}	81	}
76		82
77	if ($id !== '')	83	if ($id !== '')
78	{	84	{
79	$this->_id = $id;	85	$this->id = $id;
80	}	86	}
81	}	87	}
82		88
83	/**	89	/**
-		90	* @param string $value
-		91	*/
-		92	public function setName ($value)
-		93	{
-		94	$class = \get_class($this);
-		95	$class::$_name = (string) $value;
-		96	}
-		97
-		98	/**
-		99	* @return string
-		100	*/
-		101	public function getName ()
-		102	{
-		103	$class = \get_class($this);
-		104	return $class::$_name;
-		105	}
-		106
-		107	/**
84	* Returns the database for the table	108	* Returns the database for the table
85	* @return Database	109	* @return Database
86	*/	110	*/
87	public function getDatabase()	111	public function getDatabase()
88	{	112	{
-		113	$class = \get_class($this);
89	if (\is_string($this->_database))	114	if (\is_string($class::$_database))
90	{	115	{
91	/* Call setter to convert to Database */	116	/* Call setter to convert to Database */
92	$this->database = $this->_database;	117	$this->setDatabase($class::$_database);
93	}	118	}
94		119
95	return $this->_database;	120	return $class::$_database;
96	}	121	}
97		122
98	/**	123	/**
99	* @param Database\|string $value	124	* @param Database\|string $value
100	* @throws InvalidArgumentException	125	* @throws InvalidArgumentException
101	*/	126	*/
102	public function setDatabase ($value)	127	public function setDatabase ($value)
103	{	128	{
-		129	$class = \get_class($this);
104	if ($value instanceof Database)	130	if ($value instanceof Database)
105	{	131	{
106	$this->_database = $value;	132	$class::$_database = $value;
107	}	133	}
108	else if ($value !== null)	134	else if ($value !== null)
109	{	135	{
110	$database = new $value();	136	$database = new $value();
111	if (!($database instanceof Database))	137	if (!($database instanceof Database))
112	{	138	{
113	throw new \InvalidArgumentException(	139	throw new \InvalidArgumentException(
114	'Expected Database instance or string for class name, saw '	140	'Expected Database instance or string for class name, saw '
115	. (\get_class($value) \|\| \gettype($value))	141	. (\is_object($value) ? \get_class($value) : \gettype($value))
116	);	142	);
117	}	143	}
118		144
119	$this->_database = $database;	145	$class::$_database = $database;
120	}	146	}
121	}	147	}
122		148
123	/**	149	/**
-		150	* @param string $value
-		151	*/
-		152	public function setId ($value)
-		153	{
-		154	$class = \get_class($this);
-		155	$class::$_id = (string) $value;
-		156	}
-		157
-		158	/**
-		159	* @return string
-		160	*/
-		161	public function getId ()
-		162	{
-		163	$class = \get_class($this);
-		164	return $class::$_id;
-		165	}
-		166
-		167	/**
124	* Initiates a transaction	168	* Initiates a transaction
125	*	169	*
126	* @return bool	170	* @return bool
127	* @see Database::beginTransaction()	171	* @see Database::beginTransaction()
128	*/	172	*/
129	public function beginTransaction()	173	public function beginTransaction()
130	{	174	{
131	return $this->_database->beginTransaction();	175	return $this->database->beginTransaction();
132	}	176	}
133		177
134	/**	178	/**
135	* Rolls back a transaction	179	* Rolls back a transaction
136	*	180	*
137	* @return bool	181	* @return bool
138	* @see Database::rollBack()	182	* @see Database::rollBack()
139	*/	183	*/
140	public function rollBack()	184	public function rollBack()
141	{	185	{
142	return $this->_database->rollBack();	186	return $this->database->rollBack();
143	}	187	}
144		188
145	/**	189	/**
146	* Commits a transaction	190	* Commits a transaction
147	*	191	*
148	* @return bool	192	* @return bool
149	* @see Database::commit()	193	* @see Database::commit()
150	*/	194	*/
151	public function commit()	195	public function commit()
152	{	196	{
153	return $this->_database->commit();	197	return $this->database->commit();
154	}	198	}
155		199
156	/**	200	/**
157	* Retrieves all rows from the table	201	* Retrieves all rows from the table
158	*	202	*
159	* @return array	203	* @return array
160	* @see Database::fetchAll()	204	* @see Database::fetchAll()
161	*/	205	*/
162	public function fetchAll($fetch_style = null, $column_index = null, array $ctor_args = null)	206	public function fetchAll($fetch_style = null, $column_index = null, array $ctor_args = null)
163	{	207	{
164	return $this->_database->fetchAll($this->_name, $fetch_style, $column_index, $ctor_args);	208	return $this->database->fetchAll($this->name, $fetch_style, $column_index, $ctor_args);
165	}	209	}
166		210
167	/**	211	/**
168	* Selects data from one or more tables	212	* Selects data from one or more tables
169	*	213	*
170	* @return array	214	* @return array
171	* @see Database::select()	215	* @see Database::select()
172	*/	216	*/
173	public function select($columns = null, $where = null, $order = null, $limit = null)	217	public function select($columns = null, $where = null, $order = null, $limit = null)
174	{	218	{
175	return $this->_database->select($this->_name, $columns, $where, $order, $limit);	219	return $this->database->select($this->name, $columns, $where, $order, $limit);
176	}	220	}
177		221
178	/**	222	/**
179	* Updates records in one or more tables	223	* Updates records in one or more tables
180	*	224	*
181	* @return bool	225	* @return bool
182	* @see Database::update()	226	* @see Database::update()
183	*/	227	*/
184	public function update($data, $condition)	228	public function update($data, $condition)
185	{	229	{
186	return $this->_database->update($this->_name, $data, $condition);	230	return $this->database->update($this->name, $data, $condition);
187	}	231	}
188		232
189	/**	233	/**
190	* Inserts a record into the table	234	* Inserts a record into the table
191	*	235	*
192	* @return bool	236	* @return bool
193	* @see Database::insert()	237	* @see Database::insert()
194	*/	238	*/
195	public function insert($data, $cols = null)	239	public function insert($data, $cols = null)
196	{	240	{
197	return $this->_database->insert($this->_name, $data, $cols);	241	return $this->database->insert($this->name, $data, $cols);
198	}	242	}
199		243
200	/**	244	/**
201	* Returns the ID of the last inserted row, or the last value from	245	* Returns the ID of the last inserted row, or the last value from
202	* a sequence object, depending on the underlying driver.	246	* a sequence object, depending on the underlying driver.
Line 204...	Line 248...
204	* @return int	248	* @return int
205	* @see Database::getLastInsertId()	249	* @see Database::getLastInsertId()
206	*/	250	*/
207	public function getLastInsertId()	251	public function getLastInsertId()
208	{	252	{
209	return $this->_database->lastInsertId;	253	return $this->database->lastInsertId;
210	}	254	}
211		255
212	/**	256	/**
213	* Delete a record from the table	257	* Delete a record from the table
214	*	258	*
Line 226...	Line 270...
226	*/	270	*/
227	public function delete ($id, array $condition = null)	271	public function delete ($id, array $condition = null)
228	{	272	{
229	if ($id !== null)	273	if ($id !== null)
230	{	274	{
231	$condition = array($this->_id => $id);	275	$condition = array($this->id => $id);
232	}	276	}
233	else if ($condition === null)	277	else if ($condition === null)
234	{	278	{
235	throw new InvalidArgumentException(	279	throw new InvalidArgumentException(
236	'$id and $condition cannot both be null');	280	'$id and $condition cannot both be null');
237	}	281	}
238		282
239	return $this->_database->delete($this->_name, $condition);	283	return $this->database->delete($this->name, $condition);
240	}	284	}
241		285
242	/**	286	/**
243	* Inserts a row into the table or updates an existing one	287	* Inserts a row into the table or updates an existing one
244	*	288	*
Line 251...	Line 295...
251	* @see Table::update()	295	* @see Table::update()
252	* @see Table::insert()	296	* @see Table::insert()
253	*/	297	*/
254	public function updateOrInsert($data, array $condition = null)	298	public function updateOrInsert($data, array $condition = null)
255	{	299	{
256	if ($this->select($this->_id, $condition))	300	if ($this->select($this->id, $condition))
257	{	301	{
258	return $this->update($data, $condition);	302	return $this->update($data, $condition);
259	}	303	}
260		304
261	return $this->insert($data);	305	return $this->insert($data);
Line 273...	Line 317...
273	if (defined('DEBUG') && DEBUG > 0)	317	if (defined('DEBUG') && DEBUG > 0)
274	{	318	{
275	debug($id);	319	debug($id);
276	}	320	}
277		321
278	$result = $this->select(null, array($this->_id => $id));	322	$result = $this->select(null, array($this->id => $id));
279		323
280	if ($result)	324	if ($result)
281	{	325	{
282	$result = $result[0];	326	$result = $result[0];
283	}	327	}

Subversion Repositories PHPX

(root)/trunk/Db/Table.php @ 79 - Rev 52 → 56