Class yii\db\oci\Schema

                protected function createColumn($column)
{
    $c = $this->createColumnSchema();
    $c->name = $column['COLUMN_NAME'];
    $c->allowNull = $column['NULLABLE'] === 'Y';
    $c->comment = $column['COLUMN_COMMENT'] === null ? '' : $column['COLUMN_COMMENT'];
    $c->isPrimaryKey = false;
    $this->extractColumnType($c, $column['DATA_TYPE'], $column['DATA_PRECISION'], $column['DATA_SCALE'], $column['DATA_LENGTH']);
    $this->extractColumnSize($c, $column['DATA_TYPE'], $column['DATA_PRECISION'], $column['DATA_SCALE'], $column['DATA_LENGTH']);
    $c->phpType = $this->getColumnPhpType($c);
    if (!$c->isPrimaryKey) {
        if (stripos((string) $column['DATA_DEFAULT'], 'timestamp') !== false) {
            $c->defaultValue = null;
        } else {
            $defaultValue = (string) $column['DATA_DEFAULT'];
            if ($c->type === 'timestamp' && $defaultValue === 'CURRENT_TIMESTAMP') {
                $c->defaultValue = new Expression('CURRENT_TIMESTAMP');
            } else {
                if ($defaultValue !== null) {
                    if (
                        strlen($defaultValue) > 2
                        && strncmp($defaultValue, "'", 1) === 0
                        && substr($defaultValue, -1) === "'"
                    ) {
                        $defaultValue = substr($defaultValue, 1, -1);
                    } else {
                        $defaultValue = trim($defaultValue);
                    }
                }
                $c->defaultValue = $c->phpTypecast($defaultValue);
            }
        }
    }
    return $c;
}

            

                public function createColumnSchemaBuilder($type, $length = null)
{
    return new ColumnSchemaBuilder($type, $length, $this->db);
}

            

                public function createQueryBuilder()
{
    return new QueryBuilder($this->db);
}

            

                protected function extractColumnSize($column, $dbType, $precision, $scale, $length)
{
    $column->size = trim((string) $length) === '' ? null : (int) $length;
    $column->precision = trim((string) $precision) === '' ? null : (int) $precision;
    $column->scale = trim((string) $scale) === '' ? null : (int) $scale;
}

            

                protected function extractColumnType($column, $dbType, $precision, $scale, $length)
{
    $column->dbType = $dbType;
    if (strpos($dbType, 'FLOAT') !== false || strpos($dbType, 'DOUBLE') !== false) {
        $column->type = 'double';
    } elseif (strpos($dbType, 'NUMBER') !== false) {
        if ($scale === null || $scale > 0) {
            $column->type = 'decimal';
        } else {
            $column->type = 'integer';
        }
    } elseif (strpos($dbType, 'INTEGER') !== false) {
        $column->type = 'integer';
    } elseif (strpos($dbType, 'BLOB') !== false) {
        $column->type = 'binary';
    } elseif (strpos($dbType, 'CLOB') !== false) {
        $column->type = 'text';
    } elseif (strpos($dbType, 'TIMESTAMP') !== false) {
        $column->type = 'timestamp';
    } else {
        $column->type = 'string';
    }
}

            

                protected function findColumns($table)
{
    $sql = <<<'SQL'
CT
A.COLUMN_NAME,
A.DATA_TYPE,
A.DATA_PRECISION,
A.DATA_SCALE,
(
  CASE A.CHAR_USED WHEN 'C' THEN A.CHAR_LENGTH
    ELSE A.DATA_LENGTH
  END
) AS DATA_LENGTH,
A.NULLABLE,
A.DATA_DEFAULT,
COM.COMMENTS AS COLUMN_COMMENT
 ALL_TAB_COLUMNS A
INNER JOIN ALL_OBJECTS B ON B.OWNER = A.OWNER AND LTRIM(B.OBJECT_NAME) = LTRIM(A.TABLE_NAME)
LEFT JOIN ALL_COL_COMMENTS COM ON (A.OWNER = COM.OWNER AND A.TABLE_NAME = COM.TABLE_NAME AND A.COLUMN_NAME = COM.COLUMN_NAME)
E
A.OWNER = :schemaName
AND B.OBJECT_TYPE IN ('TABLE', 'VIEW', 'MATERIALIZED VIEW')
AND B.OBJECT_NAME = :tableName
R BY A.COLUMN_ID

    try {
        $columns = $this->db->createCommand($sql, [
            ':tableName' => $table->name,
            ':schemaName' => $table->schemaName,
        ])->queryAll();
    } catch (\Exception $e) {
        return false;
    }
    if (empty($columns)) {
        return false;
    }
    foreach ($columns as $column) {
        if ($this->db->slavePdo->getAttribute(\PDO::ATTR_CASE) === \PDO::CASE_LOWER) {
            $column = array_change_key_case($column, CASE_UPPER);
        }
        $c = $this->createColumn($column);
        $table->columns[$c->name] = $c;
    }
    return true;
}

            

                protected function findConstraints($table)
{
    $sql = <<<'SQL'
CT
/*+ PUSH_PRED(C) PUSH_PRED(D) PUSH_PRED(E) */
D.CONSTRAINT_NAME,
D.CONSTRAINT_TYPE,
C.COLUMN_NAME,
C.POSITION,
D.R_CONSTRAINT_NAME,
E.TABLE_NAME AS TABLE_REF,
F.COLUMN_NAME AS COLUMN_REF,
C.TABLE_NAME
 ALL_CONS_COLUMNS C
INNER JOIN ALL_CONSTRAINTS D ON D.OWNER = C.OWNER AND D.CONSTRAINT_NAME = C.CONSTRAINT_NAME
LEFT JOIN ALL_CONSTRAINTS E ON E.OWNER = D.R_OWNER AND E.CONSTRAINT_NAME = D.R_CONSTRAINT_NAME
LEFT JOIN ALL_CONS_COLUMNS F ON F.OWNER = E.OWNER AND F.CONSTRAINT_NAME = E.CONSTRAINT_NAME AND F.POSITION = C.POSITION
E
C.OWNER = :schemaName
AND C.TABLE_NAME = :tableName
R BY D.CONSTRAINT_NAME, C.POSITION

    $command = $this->db->createCommand($sql, [
        ':tableName' => $table->name,
        ':schemaName' => $table->schemaName,
    ]);
    $constraints = [];
    foreach ($command->queryAll() as $row) {
        if ($this->db->slavePdo->getAttribute(\PDO::ATTR_CASE) === \PDO::CASE_LOWER) {
            $row = array_change_key_case($row, CASE_UPPER);
        }
        if ($row['CONSTRAINT_TYPE'] === 'P') {
            $table->columns[$row['COLUMN_NAME']]->isPrimaryKey = true;
            $table->primaryKey[] = $row['COLUMN_NAME'];
            if (empty($table->sequenceName)) {
                $table->sequenceName = $this->getTableSequenceName($table->name);
            }
        }
        if ($row['CONSTRAINT_TYPE'] !== 'R') {
            // this condition is not checked in SQL WHERE because of an Oracle Bug:
            // see https://github.com/yiisoft/yii2/pull/8844
            continue;
        }
        $name = $row['CONSTRAINT_NAME'];
        if (!isset($constraints[$name])) {
            $constraints[$name] = [
                'tableName' => $row['TABLE_REF'],
                'columns' => [],
            ];
        }
        $constraints[$name]['columns'][$row['COLUMN_NAME']] = $row['COLUMN_REF'];
    }
    foreach ($constraints as $constraint) {
        $name = current(array_keys($constraint));
        $table->foreignKeys[$name] = array_merge([$constraint['tableName']], $constraint['columns']);
    }
}

            

                protected function findSchemaNames()
{
    static $sql = <<<'SQL'
CT "u"."USERNAME"
 "DBA_USERS" "u"
E "u"."DEFAULT_TABLESPACE" NOT IN ('SYSTEM', 'SYSAUX')
R BY "u"."USERNAME" ASC

    return $this->db->createCommand($sql)->queryColumn();
}

            

                protected function findTableNames($schema = '')
{
    if ($schema === '') {
        $sql = <<<'SQL'
CT
TABLE_NAME
 USER_TABLES
N ALL
CT
VIEW_NAME AS TABLE_NAME
 USER_VIEWS
N ALL
CT
MVIEW_NAME AS TABLE_NAME
 USER_MVIEWS
R BY TABLE_NAME

        $command = $this->db->createCommand($sql);
    } else {
        $sql = <<<'SQL'
CT
OBJECT_NAME AS TABLE_NAME
 ALL_OBJECTS
E
OBJECT_TYPE IN ('TABLE', 'VIEW', 'MATERIALIZED VIEW')
AND OWNER = :schema
R BY OBJECT_NAME

        $command = $this->db->createCommand($sql, [':schema' => $schema]);
    }
    $rows = $command->queryAll();
    $names = [];
    foreach ($rows as $row) {
        if ($this->db->slavePdo->getAttribute(\PDO::ATTR_CASE) === \PDO::CASE_LOWER) {
            $row = array_change_key_case($row, CASE_UPPER);
        }
        $names[] = $row['TABLE_NAME'];
    }
    return $names;
}

            

                public function findUniqueIndexes($table)
{
    $query = <<<'SQL'
CT
DIC.INDEX_NAME,
DIC.COLUMN_NAME
 ALL_INDEXES DI
INNER JOIN ALL_IND_COLUMNS DIC ON DI.TABLE_NAME = DIC.TABLE_NAME AND DI.INDEX_NAME = DIC.INDEX_NAME
E
DI.UNIQUENESS = 'UNIQUE'
AND DIC.TABLE_OWNER = :schemaName
AND DIC.TABLE_NAME = :tableName
R BY DIC.TABLE_NAME, DIC.INDEX_NAME, DIC.COLUMN_POSITION

    $result = [];
    $command = $this->db->createCommand($query, [
        ':tableName' => $table->name,
        ':schemaName' => $table->schemaName,
    ]);
    foreach ($command->queryAll() as $row) {
        $result[$row['INDEX_NAME']][] = $row['COLUMN_NAME'];
    }
    return $result;
}

            

                public function getLastInsertID($sequenceName = '')
{
    if ($this->db->isActive) {
        // get the last insert id from the master connection
        $sequenceName = $this->quoteSimpleTableName($sequenceName);
        return $this->db->useMaster(function (Connection $db) use ($sequenceName) {
            return $db->createCommand("SELECT {$sequenceName}.CURRVAL FROM DUAL")->queryScalar();
        });
    } else {
        throw new InvalidCallException('DB Connection is not active.');
    }
}

            

                public function init()
{
    parent::init();
    if ($this->defaultSchema === null) {
        $username = $this->db->username;
        if (empty($username)) {
            $username = isset($this->db->masters[0]['username']) ? $this->db->masters[0]['username'] : '';
        }
        $this->defaultSchema = strtoupper($username);
    }
}

            

                public function insert($table, $columns)
{
    $params = [];
    $returnParams = [];
    $sql = $this->db->getQueryBuilder()->insert($table, $columns, $params);
    $tableSchema = $this->getTableSchema($table);
    $returnColumns = $tableSchema->primaryKey;
    if (!empty($returnColumns)) {
        $columnSchemas = $tableSchema->columns;
        $returning = [];
        foreach ((array) $returnColumns as $name) {
            $phName = QueryBuilder::PARAM_PREFIX . (count($params) + count($returnParams));
            $returnParams[$phName] = [
                'column' => $name,
                'value' => '',
            ];
            if (!isset($columnSchemas[$name]) || $columnSchemas[$name]->phpType !== 'integer') {
                $returnParams[$phName]['dataType'] = \PDO::PARAM_STR;
            } else {
                $returnParams[$phName]['dataType'] = \PDO::PARAM_INT;
            }
            $returnParams[$phName]['size'] = isset($columnSchemas[$name]->size) ? $columnSchemas[$name]->size : -1;
            $returning[] = $this->quoteColumnName($name);
        }
        $sql .= ' RETURNING ' . implode(', ', $returning) . ' INTO ' . implode(', ', array_keys($returnParams));
    }
    $command = $this->db->createCommand($sql, $params);
    $command->prepare(false);
    foreach ($returnParams as $name => &$value) {
        $command->pdoStatement->bindParam($name, $value['value'], $value['dataType'], $value['size']);
    }
    if (!$command->execute()) {
        return false;
    }
    $result = [];
    foreach ($returnParams as $value) {
        $result[$value['column']] = $value['value'];
    }
    return $result;
}

            

                protected function loadTableChecks($tableName)
{
    return $this->loadTableConstraints($tableName, 'checks');
}

            

                protected function loadTableDefaultValues($tableName)
{
    throw new NotSupportedException('Oracle does not support default value constraints.');
}

            

                protected function loadTableForeignKeys($tableName)
{
    return $this->loadTableConstraints($tableName, 'foreignKeys');
}

            

                protected function loadTableIndexes($tableName)
{
    static $sql = <<<'SQL'
CT
/*+ PUSH_PRED("ui") PUSH_PRED("uicol") PUSH_PRED("uc") */
"ui"."INDEX_NAME" AS "name",
"uicol"."COLUMN_NAME" AS "column_name",
CASE "ui"."UNIQUENESS" WHEN 'UNIQUE' THEN 1 ELSE 0 END AS "index_is_unique",
CASE WHEN "uc"."CONSTRAINT_NAME" IS NOT NULL THEN 1 ELSE 0 END AS "index_is_primary"
 "SYS"."USER_INDEXES" "ui"
 JOIN "SYS"."USER_IND_COLUMNS" "uicol"
ON "uicol"."INDEX_NAME" = "ui"."INDEX_NAME"
 JOIN "SYS"."USER_CONSTRAINTS" "uc"
ON "uc"."OWNER" = "ui"."TABLE_OWNER" AND "uc"."CONSTRAINT_NAME" = "ui"."INDEX_NAME" AND "uc"."CONSTRAINT_TYPE" = 'P'
E "ui"."TABLE_OWNER" = :schemaName AND "ui"."TABLE_NAME" = :tableName
R BY "uicol"."COLUMN_POSITION" ASC

    $resolvedName = $this->resolveTableName($tableName);
    $indexes = $this->db->createCommand($sql, [
        ':schemaName' => $resolvedName->schemaName,
        ':tableName' => $resolvedName->name,
    ])->queryAll();
    $indexes = $this->normalizePdoRowKeyCase($indexes, true);
    $indexes = ArrayHelper::index($indexes, null, 'name');
    $result = [];
    foreach ($indexes as $name => $index) {
        $result[] = new IndexConstraint([
            'isPrimary' => (bool) $index[0]['index_is_primary'],
            'isUnique' => (bool) $index[0]['index_is_unique'],
            'name' => $name,
            'columnNames' => ArrayHelper::getColumn($index, 'column_name'),
        ]);
    }
    return $result;
}

            

                protected function loadTablePrimaryKey($tableName)
{
    return $this->loadTableConstraints($tableName, 'primaryKey');
}

            

                protected function loadTableSchema($name)
{
    $table = new TableSchema();
    $this->resolveTableNames($table, $name);
    if ($this->findColumns($table)) {
        $this->findConstraints($table);
        return $table;
    }
    return null;
}

            

                protected function loadTableUniques($tableName)
{
    return $this->loadTableConstraints($tableName, 'uniques');
}

            

                public function quoteSimpleTableName($name)
{
    return strpos($name, '"') !== false ? $name : '"' . $name . '"';
}

            

                public function releaseSavepoint($name)
{
    // does nothing as Oracle does not support this
}

            

                protected function resolveTableName($name)
{
    $resolvedName = new TableSchema();
    $parts = explode('.', str_replace('"', '', $name));
    if (isset($parts[1])) {
        $resolvedName->schemaName = $parts[0];
        $resolvedName->name = $parts[1];
    } else {
        $resolvedName->schemaName = $this->defaultSchema;
        $resolvedName->name = $name;
    }
    $resolvedName->fullName = ($resolvedName->schemaName !== $this->defaultSchema ? $resolvedName->schemaName . '.' : '') . $resolvedName->name;
    return $resolvedName;
}

            

                protected function resolveTableNames($table, $name)
{
    $parts = explode('.', str_replace('"', '', $name));
    if (isset($parts[1])) {
        $table->schemaName = $parts[0];
        $table->name = $parts[1];
    } else {
        $table->schemaName = $this->defaultSchema;
        $table->name = $name;
    }
    $table->fullName = $table->schemaName !== $this->defaultSchema ? $table->schemaName . '.' . $table->name : $table->name;
}