Path

ez components / documentation / api reference / 2009.1.2 / database


eZ Components 2009.1.2

DatabaseSchema

[ Tutorial ] [ Class tree ] [ Element index ] [ ChangeLog ] [ Credits ]

Source for file common_sql_writer.php

Documentation is available at common_sql_writer.php

  1. <?php
  2. /**
  3.  * File containing the ezcDbSchemaCommonSqlWriter class.
  4.  *
  5.  * @package DatabaseSchema
  6.  * @version 1.4.2
  7.  * @copyright Copyright (C) 2005-2008 eZ systems as. All rights reserved.
  8.  * @license http://ez.no/licenses/new_bsd New BSD License
  9.  */
 10.  
 11. /**
 12.  * An abstract class that implements some common functionality required by
 13.  * multiple database backends.
 14.  *
 15.  * @package DatabaseSchema
 16.  * @version 1.4.2
 17.  */
 18. abstract class ezcDbSchemaCommonSqlWriter implements ezcDbSchemaDbWriterezcDbSchemaDiffDbWriter
 19. {
 20.     /**
 21.      * Stores a list of queries that is generated by the various Database writing backends.
 22.      *
 23.      * @var array(string) 
 24.      */
 25.     protected $queries;
 26.  
 27.     /**
 28.      * Stores the schema definition where the generators operate on.
 29.      *
 30.      * @var ezcDbSchema 
 31.      */
 32.     protected $schema;
 33.  
 34.     /**
 35.      * Returns what type of schema writer this class implements.
 36.      *
 37.      * This method always returns ezcDbSchema::DATABASE
 38.      *
 39.      * @return int 
 40.      */
 41.     public function getWriterType()
 42.     {
 43.         return ezcDbSchema::DATABASE;
 44.     }
 45.  
 46.     /**
 47.      * Creates the tables contained in $schema in the database that is related to $db
 48.      *
 49.      * This method takes the table definitions from $schema and will create the
 50.      * tables according to this definition in the database that is references
 51.      * by the $db handler. If tables with the same name as contained in the
 52.      * definitions already exist they will be removed and recreated with the
 53.      * new definition.
 54.      *
 55.      * @param ezcDbHandler $db 
 56.      * @param ezcDbSchema  $dbSchema 
 57.      */
 58.     public function saveToDbezcDbHandler $dbezcDbSchema $dbSchema )
 59.     {
 60.         $db->beginTransaction();
 61.         foreach $this->convertToDDL$dbSchema as $query )
 62.         {
 63.             if $this->isQueryAllowed$db$query ) ) 
 64.             {
 65.                 $db->exec$query );
 66.             }
 67.         }
 68.         $db->commit();
 69.     }
 70.  
 71.     /**
 72.      * Returns an array with SQL DDL statements that creates the database definition in $dbSchema
 73.      *
 74.      * Converts the schema definition contained in $dbSchema to DDL SQL. This
 75.      * SQL can be used to create tables in an existing database according to
 76.      * the definition.  The SQL queries are returned as an array.
 77.      * 
 78.      * @param ezcDbSchema $dbSchema 
 79.      * @return array(string) 
 80.      */
 81.     public function convertToDDLezcDbSchema $dbSchema )
 82.     {
 83.         $this->schema = $dbSchema->getSchema();
 84.  
 85.         // reset queries
 86.         $this->queries = array();
 87.         $this->context array();
 88.  
 89.         $this->generateSchemaAsSql();
 90.         return $this->queries;
 91.     }
 92.  
 93.     /**
 94.      * Checks if the query is allowed.
 95.      *
 96.      * Perform testing if table exist for DROP TABLE query
 97.      * to avoid stoping execution while try to drop not existent table.
 98.      * 
 99.      * @param ezcDbHandler $db 
100.      * @param string       $query 
101.      * 
102.      * @return boolean 
103.      */
104.     public function isQueryAllowedezcDbHandler $db$query )
105.     {
106.         return true;
107.     }
108.  
109.     /**
110.      * Creates SQL DDL statements from a schema definitin.
111.      *
112.      * Loops over the tables in the schema definition in $this->schema and
113.      * creates SQL SSL statements for this which it stores internally into the
114.      * $this->queries array.
115.      */
116.     protected function generateSchemaAsSql()
117.     {
118.         $prefix ezcDbSchema::$options->tableNamePrefix;
119.         foreach $this->schema as $tableName => $tableDefinition )
120.         {
121.             $this->generateDropTableSql$prefix $tableName );
122.             $this->generateCreateTableSql$prefix $tableName$tableDefinition );
123.         }
124.     }
125.  
126.     /**
127.      * Returns a "CREATE TABLE" SQL statement part for the table $tableName.
128.      *
129.      * @param string  $tableName 
130.      * @return string 
131.      */
132.     protected function generateCreateTableSqlStatement$tableName )
133.     {
134.         return "CREATE TABLE $tableName";
135.     }
136.  
137.     /**
138.      * Adds a "create table" query for the table $tableName with definition $tableDefinition to the internal list of queries.
139.      *
140.      * @param string           $tableName 
141.      * @param ezcDbSchemaTable $tableDefinition 
142.      */
143.     protected function generateCreateTableSql$tableNameezcDbSchemaTable $tableDefinition )
144.     {
145.         $sql $this->generateCreateTableSqlStatement$tableName );
146.  
147.         $sql .= " (\n";
148.  
149.         // dump fields
150.         $fieldsSQL array();
151.  
152.         foreach $tableDefinition->fields as $fieldName => $fieldDefinition )
153.         {
154.             $fieldsSQL["\t" $this->generateFieldSql$fieldName$fieldDefinition );
155.         }
156.  
157.         $sql .= join",\n"$fieldsSQL );
158.  
159.         $sql .= "\n)";
160.  
161.         $this->queries[$sql;
162.  
163.         // dump indexes
164.         foreach $tableDefinition->indexes as $indexName => $indexDefinition)
165.         {
166.             $fieldsSQL[$this->generateAddIndexSql$tableName$indexName$indexDefinition );
167.         }
168.     }
169.  
170.     /**
171.      * Returns an appropriate default value for $type with $value.
172.      *
173.      * @param string $type 
174.      * @param mixed  $value 
175.      * @return string 
176.      */
177.     protected function generateDefault$type$value )
178.     {
179.         switch $type )
180.         {
181.             case 'boolean':
182.                 return $value && $value != 'false' 'true' 'false';
183.  
184.             case 'integer':
185.                 return (int) $value;
186.  
187.             case 'float':
188.             case 'decimal':
189.                 return (float) $value;
190.  
191.             case 'timestamp':
192.                 return (int) $value;
193.  
194.             default:
195.                 return "'$value'";
196.         }
197.     }
198.  
199.     /**
200.      * Generates queries to upgrade an existing database with the changes stored in $this->diffSchema.
201.      *
202.      * This method generates queries to migrate a database to a new version
203.      * with the changes that are stored in the $this->diffSchema property. It
204.      * will call different subfunctions for the different types of changes, and
205.      * those functions will add queries to the internal list of queries that is
206.      * stored in $this->queries.
207.      */
208.     protected function generateDiffSchemaAsSql()
209.     {
210.         foreach $this->diffSchema->changedTables as $tableName => $tableDiff )
211.         {
212.             $this->generateDiffSchemaTableAsSql$tableName$tableDiff );
213.         }
214.  
215.         foreach $this->diffSchema->newTables as $tableName => $tableDef )
216.         {
217.             $this->generateCreateTableSql$tableName$tableDef );
218.         }
219.  
220.         foreach $this->diffSchema->removedTables as $tableName => $dummy )
221.         {
222.             $this->generateDropTableSql$tableName );
223.         }
224.     }
225.  
226.     /**
227.      * Generates queries to upgrade a the table $tableName with the differences in $tableDiff.
228.      *
229.      * This method generates queries to migrate a table to a new version
230.      * with the changes that are stored in the $tableDiff property. It
231.      * will call different subfunctions for the different types of changes, and
232.      * those functions will add queries to the internal list of queries that is
233.      * stored in $this->queries.
234.      *
235.      * @param string $tableName 
236.      * @param ezcDbSchemaTableDiff $tableDiff 
237.      */
238.     protected function generateDiffSchemaTableAsSql$tableNameezcDbSchemaTableDiff $tableDiff )
239.     {
240.         foreach $tableDiff->removedIndexes as $indexName => $isRemoved )
241.         {
242.             if $isRemoved )
243.             {
244.                 $this->generateDropIndexSql$tableName$indexName );
245.             }
246.         }
247.  
248.         foreach $tableDiff->changedIndexes as $indexName => $indexDefinition )
249.         {
250.             $this->generateDropIndexSql$tableName$indexName );
251.         }
252.  
253.         foreach $tableDiff->removedFields as $fieldName => $isRemoved )
254.         {
255.             if $isRemoved )
256.             {
257.                 $this->generateDropFieldSql$tableName$fieldName );
258.             }
259.         }
260.  
261.         foreach $tableDiff->changedFields as $fieldName => $fieldDefinition )
262.         {
263.             $this->generateChangeFieldSql$tableName$fieldName$fieldDefinition );
264.         }
265.  
266.         foreach $tableDiff->addedFields as $fieldName => $fieldDefinition )
267.         {
268.             $this->generateAddFieldSql$tableName$fieldName$fieldDefinition );
269.         }
270.  
271.         foreach $tableDiff->changedIndexes as $indexName => $indexDefinition )
272.         {
273.             $this->generateAddIndexSql$tableName$indexName$indexDefinition );
274.         }
275.  
276.         foreach $tableDiff->addedIndexes as $indexName => $indexDefinition )
277.         {
278.             $this->generateAddIndexSql$tableName$indexName$indexDefinition );
279.         }
280.     }
281.  
282.     /**
283.      * Adds a "drop table" query for the table $tableName to the internal list of queries.
284.      *
285.      * @param string $tableName 
286.      */
287.     protected abstract function generateDropTableSql$tableName );
288.  
289.     /**
290.      * Returns a column definition for $fieldName with definition $fieldDefinition.
291.      *
292.      * @param  string           $fieldName 
293.      * @param  ezcDbSchemaField $fieldDefinition 
294.      * @return string 
295.      */
296.     protected abstract function generateFieldSql$fieldNameezcDbSchemaField $fieldDefinition );
297.  
298.     /**
299.      * Adds a "alter table" query to add the field $fieldName to $tableName with the definition $fieldDefinition.
300.      *
301.      * @param string           $tableName 
302.      * @param string           $fieldName 
303.      * @param ezcDbSchemaField $fieldDefinition 
304.      */
305.     protected abstract function generateAddFieldSql$tableName$fieldNameezcDbSchemaField $fieldDefinition );
306.  
307.     /**
308.      * Adds a "alter table" query to change the field $fieldName to $tableName with the definition $fieldDefinition.
309.      *
310.      * @param string           $tableName 
311.      * @param string           $fieldName 
312.      * @param ezcDbSchemaField $fieldDefinition 
313.      */
314.     protected abstract function generateChangeFieldSql$tableName$fieldNameezcDbSchemaField $fieldDefinition );
315.  
316.     /**
317.      * Adds a "alter table" query to drop the field $fieldName from $tableName.
318.      *
319.      * @param string $tableName 
320.      * @param string $fieldName 
321.      */
322.     protected abstract function generateDropFieldSql$tableName$fieldName );
323.  
324.  
325.     /**
326.      * Adds a "alter table" query to add the index $indexName to the table $tableName with definition $indexDefinition to the internal list of queries
327.      *
328.      * @param string           $tableName 
329.      * @param string           $indexName 
330.      * @param ezcDbSchemaIndex $indexDefinition 
331.      */
332.     protected abstract function generateAddIndexSql$tableName$indexNameezcDbSchemaIndex $indexDefinition );
333.  
334.     /**
335.      * Adds a "alter table" query to remote the index $indexName from the table $tableName to the internal list of queries.
336.      *
337.      * @param string           $tableName 
338.      * @param string           $indexName 
339.      */
340.     protected abstract function generateDropIndexSql$tableName$indexName );
341. }
342. ?>
Last updated: Tue, 01 Sep 2009