Doctrine 1.2.4
Public Member Functions
Doctrine_Import_Oracle Class Reference

Inherits Doctrine_Import.

Public Member Functions

 databaseExists ($database)
 
 functionExists ($function)
 
 getConnection ()
 
 getModuleName ()
 
 importSchema ($directory, array $connections=array(), array $options=array())
 
 listDatabases ()
 
 listFunctions ()
 
 listSequences ($database=null)
 
 listTableColumns ($table)
 
 listTableConstraints ($table)
 
 listTableIndexes ($table)
 
 listTableRelations ($table)
 
 listTables ($database=null)
 
 listTableTriggers ($table)
 
 listTableViews ($table)
 
 listTriggers ($database=null)
 
 listUsers ()
 
 listViews ($database=null)
 
 sequenceExists ($sequence, $database=null)
 
 tableColumnExists ($column, $table)
 
 tableConstraintExists ($constraint, $table)
 
 tableExists ($table, $database=null)
 
 tableIndexExists ($index, $table)
 
 tableTriggerExists ($trigger, $table)
 
 tableViewExists ($view, $table)
 
 triggerExists ($trigger, $database=null)
 
 userExists ($user)
 
 viewExists ($view, $database=null)
 

Detailed Description

Definition at line 31 of file Oracle.php.

Member Function Documentation

Doctrine_Import::databaseExists (   $database)
inherited

checks if a database exists

Parameters
string$database
Returns
boolean

Definition at line 220 of file Import.php.

{
return in_array($database, $this->listDatabases());
}
Doctrine_Import::functionExists (   $function)
inherited

checks if a function exists

Parameters
string$function
Returns
boolean

Definition at line 231 of file Import.php.

{
return in_array($function, $this->listFunctions());
}
Doctrine_Connection_Module::getConnection ( )
inherited

getConnection returns the connection object this module uses

Returns
Doctrine_Connection

Definition at line 68 of file Module.php.

{
return $this->conn;
}
Doctrine_Connection_Module::getModuleName ( )
inherited

getModuleName returns the name of this module

Returns
string the name of this module

Definition at line 79 of file Module.php.

{
return $this->moduleName;
}
Doctrine_Import::importSchema (   $directory,
array  $connections = array(),
array  $options = array() 
)
inherited

importSchema

method for importing existing schema to Doctrine_Record classes

Parameters
string$directory
array$connectionsArray of connection names to generate models for
Returns
array the names of the imported classes

Definition at line 364 of file Import.php.

{
$classes = array();
$manager = Doctrine_Manager::getInstance();
foreach ($manager as $name => $connection) {
// Limit the databases to the ones specified by $connections.
// Check only happens if array is not empty
if ( ! empty($connections) && ! in_array($name, $connections)) {
continue;
}
$builder = new Doctrine_Import_Builder();
$builder->setTargetPath($directory);
$builder->setOptions($options);
$definitions = array();
foreach ($connection->import->listTables() as $table) {
$definition = array();
$definition['tableName'] = $table;
$definition['className'] = Doctrine_Inflector::classify(Doctrine_Inflector::tableize($table));
$definition['columns'] = $connection->import->listTableColumns($table);
$definition['connection'] = $connection->getName();
$definition['connectionClassName'] = $definition['className'];
try {
$definition['relations'] = array();
$relations = $connection->import->listTableRelations($table);
$relClasses = array();
foreach ($relations as $relation) {
$table = $relation['table'];
$class = Doctrine_Inflector::classify(Doctrine_Inflector::tableize($table));
if (in_array($class, $relClasses)) {
$alias = $class . '_' . (count($relClasses) + 1);
} else {
$alias = $class;
}
$relClasses[] = $class;
$definition['relations'][$alias] = array(
'alias' => $alias,
'class' => $class,
'local' => $relation['local'],
'foreign' => $relation['foreign']
);
}
} catch (Exception $e) {}
$definitions[strtolower($definition['className'])] = $definition;
$classes[] = $definition['className'];
}
// Build opposite end of relationships
foreach ($definitions as $definition) {
$className = $definition['className'];
$relClasses = array();
foreach ($definition['relations'] as $alias => $relation) {
if (in_array($relation['class'], $relClasses) || isset($definitions[$relation['class']]['relations'][$className])) {
$alias = $className . '_' . (count($relClasses) + 1);
} else {
$alias = $className;
}
$relClasses[] = $relation['class'];
$definitions[strtolower($relation['class'])]['relations'][$alias] = array(
'type' => Doctrine_Relation::MANY,
'alias' => $alias,
'class' => $className,
'local' => $relation['foreign'],
'foreign' => $relation['local']
);
}
}
// Build records
foreach ($definitions as $definition) {
$builder->buildRecord($definition);
}
}
return $classes;
}
Doctrine_Import_Oracle::listDatabases ( )

lists all databases

Returns
array

Definition at line 38 of file Oracle.php.

{
if ( ! $this->conn->getAttribute(Doctrine_Core::ATTR_EMULATE_DATABASE)) {
throw new Doctrine_Import_Exception('database listing is only supported if the "emulate_database" option is enabled');
}
$query = 'SELECT username FROM sys.user_users';
$result2 = $this->conn->standaloneQuery($query);
$result = $result2->fetchColumn();
return $result;
}
Doctrine_Import_Oracle::listFunctions ( )

lists all availible database functions

Returns
array

Definition at line 57 of file Oracle.php.

{
$query = "SELECT name FROM sys.user_source WHERE line = 1 AND type = 'FUNCTION'";
return $this->conn->fetchColumn($query);
}
Doctrine_Import_Oracle::listSequences (   $database = null)

lists all database sequences

Parameters
string | null$database
Returns
array

Definition at line 82 of file Oracle.php.

{
$query = "SELECT sequence_name FROM sys.user_sequences";
$tableNames = $this->conn->fetchColumn($query);
return array_map(array($this->conn->formatter, 'fixSequenceName'), $tableNames);
}
Doctrine_Import_Oracle::listTableColumns (   $table)

lists table constraints

Parameters
string$tabledatabase table name
Returns
array

Definition at line 115 of file Oracle.php.

{
$sql = <<<QEND
SELECT tc.column_name, data_type,
CASE WHEN data_type = 'NUMBER' THEN data_precision ELSE data_length END AS data_length,
nullable, data_default, data_scale, data_precision, pk.primary
FROM all_tab_columns tc
LEFT JOIN (
select 'primary' primary, cc.table_name, cc.column_name from all_constraints cons
join all_cons_columns cc on cons.constraint_name = cc.constraint_name
where cons.constraint_type = 'P'
) pk ON pk.column_name = tc.column_name and pk.table_name = tc.table_name
WHERE tc.table_name = :tableName ORDER BY column_id
QEND;
$result = $this->conn->fetchAssoc($sql, array(':tableName' => $table));
$descr = array();
foreach($result as $val) {
$val = array_change_key_case($val, CASE_LOWER);
$decl = $this->conn->dataDict->getPortableDeclaration($val);
$descr[$val['column_name']] = array(
'name' => $val['column_name'],
'notnull' => (bool) ($val['nullable'] === 'N'),
'ntype' => $val['data_type'],
'type' => $decl['type'][0],
'alltypes' => $decl['type'],
'fixed' => (bool) $decl['fixed'],
'unsigned' => (bool) $decl['unsigned'],
'default' => $val['data_default'],
'length' => $val['data_length'],
'primary' => (bool) $val['primary'],
'scale' => isset($val['scale']) ? $val['scale']:null,
);
}
return $descr;
}
Doctrine_Import_Oracle::listTableConstraints (   $table)

lists table constraints

Parameters
string$tabledatabase table name
Returns
array

Definition at line 97 of file Oracle.php.

{
$table = $this->conn->quote($table, 'text');
$query = 'SELECT index_name name FROM user_constraints'
. ' WHERE table_name = ' . $table . ' OR table_name = ' . strtoupper($table);
$constraints = $this->conn->fetchColumn($query);
return array_map(array($this->conn->formatter, 'fixIndexName'), $constraints);
}
Doctrine_Import_Oracle::listTableIndexes (   $table)

lists table constraints

Parameters
string$tabledatabase table name
Returns
array

Definition at line 161 of file Oracle.php.

{
$table = $this->conn->quote($table, 'text');
$query = 'SELECT index_name name FROM user_indexes'
. ' WHERE table_name = ' . $table . ' OR table_name = ' . strtoupper($table)
. ' AND generated = ' . $this->conn->quote('N', 'text');
$indexes = $this->conn->fetchColumn($query);
return array_map(array($this->conn->formatter, 'fixIndexName'), $indexes);
}
Doctrine_Import_Oracle::listTableRelations (   $table)

list table relations

Definition at line 176 of file Oracle.php.

{
$relations = array();
$sql = 'SELECT '
. 'rcc.table_name AS referenced_table_name, '
. 'lcc.column_name AS local_column_name, '
. 'rcc.column_name AS referenced_column_name '
. 'FROM user_constraints ac '
. 'JOIN user_cons_columns rcc ON ac.r_constraint_name = rcc.constraint_name '
. 'JOIN user_cons_columns lcc ON ac.constraint_name = lcc.constraint_name '
. "WHERE ac.constraint_type = 'R' AND ac.table_name = :tableName";
$results = $this->conn->fetchAssoc($sql, array(':tableName' => $table));
foreach ($results as $result) {
$result = array_change_key_case($result, CASE_LOWER);
$relations[] = array('table' => $result['referenced_table_name'],
'local' => $result['local_column_name'],
'foreign' => $result['referenced_column_name']);
}
return $relations;
}
Doctrine_Import_Oracle::listTables (   $database = null)

lists tables

Parameters
string | null$database
Returns
array

Definition at line 204 of file Oracle.php.

{
$query = "SELECT * FROM user_objects WHERE object_type = 'TABLE' and object_name in (select table_name from user_tables)";
return $this->conn->fetchColumn($query);
}
Doctrine_Import_Oracle::listTableTriggers (   $table)

lists table triggers

Parameters
string$tabledatabase table name
Returns
array

Definition at line 216 of file Oracle.php.

{
}
Doctrine_Import_Oracle::listTableViews (   $table)

lists table views

Parameters
string$tabledatabase table name
Returns
array

Definition at line 227 of file Oracle.php.

{
}
Doctrine_Import_Oracle::listTriggers (   $database = null)

lists all database triggers

Parameters
string | null$database
Returns
array

Definition at line 70 of file Oracle.php.

{
$query = "SELECT trigger_name FROM sys.user_triggers";
return $this->conn->fetchColumn($query);
}
Doctrine_Import_Oracle::listUsers ( )

lists database users

Returns
array

Definition at line 237 of file Oracle.php.

{
$query = 'SELECT username FROM sys.all_users';
return $this->conn->fetchColumn($query);
}
Doctrine_Import_Oracle::listViews (   $database = null)

lists database views

Parameters
string | null$database
Returns
array

Definition at line 250 of file Oracle.php.

{
$query = 'SELECT view_name FROM sys.user_views';
return $this->conn->fetchColumn($query);
}
Doctrine_Import::sequenceExists (   $sequence,
  $database = null 
)
inherited

checks if a sequence exists

Parameters
string$sequence
string | null$database
Returns
boolean

Definition at line 255 of file Import.php.

{
return in_array($sequence, $this->listSequences($database));
}
Doctrine_Import::tableColumnExists (   $column,
  $table 
)
inherited

checks if a table column exists

Parameters
string$column
string$tabledatabase table name
Returns
boolean

Definition at line 279 of file Import.php.

{
return in_array($column, $this->listTableColumns($table));
}
Doctrine_Import::tableConstraintExists (   $constraint,
  $table 
)
inherited

checks if a table constraint exists

Parameters
string$constraint
string$tabledatabase table name
Returns
boolean

Definition at line 267 of file Import.php.

{
return in_array($constraint, $this->listTableConstraints($table));
}
Doctrine_Import::tableExists (   $table,
  $database = null 
)
inherited

checks if a table exists

Parameters
string$table
string | null$database
Returns
boolean

Definition at line 303 of file Import.php.

{
return in_array($table, $this->listTables($database));
}
Doctrine_Import::tableIndexExists (   $index,
  $table 
)
inherited

checks if a table index exists

Parameters
string$index
string$tabledatabase table name
Returns
boolean

Definition at line 291 of file Import.php.

{
return in_array($index, $this->listTableIndexes($table));
}
Doctrine_Import::tableTriggerExists (   $trigger,
  $table 
)
inherited

checks if a table trigger exists

Parameters
string$trigger
string$tabledatabase table name
Returns
boolean

Definition at line 315 of file Import.php.

{
return in_array($trigger, $this->listTableTriggers($table));
}
Doctrine_Import::tableViewExists (   $view,
  $table 
)
inherited

checks if a table view exists

Parameters
string$view
string$tabledatabase table name
Returns
boolean

Definition at line 327 of file Import.php.

{
return in_array($view, $this->listTableViews($table));
}
Doctrine_Import::triggerExists (   $trigger,
  $database = null 
)
inherited

checks if a trigger exists

Parameters
string$trigger
string | null$database
Returns
boolean

Definition at line 243 of file Import.php.

{
return in_array($trigger, $this->listTriggers($database));
}
Doctrine_Import::userExists (   $user)
inherited

checks if a user exists

Parameters
string$user
Returns
boolean

Definition at line 338 of file Import.php.

{
return in_array($user, $this->listUsers());
}
Doctrine_Import::viewExists (   $view,
  $database = null 
)
inherited

checks if a view exists

Parameters
string$view
string | null$database
Returns
boolean

Definition at line 350 of file Import.php.

{
return in_array($view, $this->listViews($database));
}
The documentation for this class was generated from the following file: