PHP xmldb_field::getLength方法代码示例

 /**
  * Given one correct xmldb_field, returns the complete SQL line to create it.
  *
  * @param xmldb_table $xmldb_table The table related to $xmldb_field.
  * @param xmldb_field $xmldb_field The instance of xmldb_field to create the SQL from.
  * @param string $skip_type_clause The type clause on alter columns, NULL by default.
  * @param string $skip_default_clause The default clause on alter columns, NULL by default.
  * @param string $skip_notnull_clause The null/notnull clause on alter columns, NULL by default.
  * @param string $specify_nulls_clause To force a specific null clause, NULL by default.
  * @param bool $specify_field_name Flag to specify fieldname in return.
  * @return string The field generating SQL statement.
  * @throws coding_exception Thrown when xmldb_field doesn't validate with the xmldb_table.
  */
 public function getFieldSQL($xmldb_table, $xmldb_field, $skip_type_clause = NULL, $skip_default_clause = NULL, $skip_notnull_clause = NULL, $specify_nulls_clause = NULL, $specify_field_name = true)
 {
     if ($error = $xmldb_field->validateDefinition($xmldb_table)) {
         throw new coding_exception($error);
     }
     $skip_type_clause = is_null($skip_type_clause) ? $this->alter_column_skip_type : $skip_type_clause;
     $skip_default_clause = is_null($skip_default_clause) ? $this->alter_column_skip_default : $skip_default_clause;
     $skip_notnull_clause = is_null($skip_notnull_clause) ? $this->alter_column_skip_notnull : $skip_notnull_clause;
     $specify_nulls_clause = is_null($specify_nulls_clause) ? $this->specify_nulls : $specify_nulls_clause;
     /// First of all, convert integers to numbers if defined
     if ($this->integer_to_number) {
         if ($xmldb_field->getType() == XMLDB_TYPE_INTEGER) {
             $xmldb_field->setType(XMLDB_TYPE_NUMBER);
         }
     }
     /// Same for floats
     if ($this->float_to_number) {
         if ($xmldb_field->getType() == XMLDB_TYPE_FLOAT) {
             $xmldb_field->setType(XMLDB_TYPE_NUMBER);
         }
     }
     $field = '';
     // Let's accumulate the whole expression based on params and settings
     /// The name
     if ($specify_field_name) {
         $field .= $this->getEncQuoted($xmldb_field->getName());
     }
     /// The type and length only if we don't want to skip it
     if (!$skip_type_clause) {
         /// The type and length
         $field .= ' ' . $this->getTypeSQL($xmldb_field->getType(), $xmldb_field->getLength(), $xmldb_field->getDecimals());
     }
     /// The unsigned if supported
     if ($this->unsigned_allowed && ($xmldb_field->getType() == XMLDB_TYPE_INTEGER || $xmldb_field->getType() == XMLDB_TYPE_NUMBER || $xmldb_field->getType() == XMLDB_TYPE_FLOAT)) {
         if ($xmldb_field->getUnsigned()) {
             $field .= ' unsigned';
         }
     }
     /// Calculate the not null clause
     $notnull = '';
     /// Only if we don't want to skip it
     if (!$skip_notnull_clause) {
         if ($xmldb_field->getNotNull()) {
             $notnull = ' NOT NULL';
         } else {
             if ($specify_nulls_clause) {
                 $notnull = ' NULL';
             }
         }
     }
     /// Calculate the default clause
     $default_clause = '';
     if (!$skip_default_clause) {
         //Only if we don't want to skip it
         $default_clause = $this->getDefaultClause($xmldb_field);
     }
     /// Based on default_after_null, set both clauses properly
     if ($this->default_after_null) {
         $field .= $notnull . $default_clause;
     } else {
         $field .= $default_clause . $notnull;
     }
     /// The sequence
     if ($xmldb_field->getSequence()) {
         if ($xmldb_field->getLength() <= 9 && $this->sequence_name_small) {
             $sequencename = $this->sequence_name_small;
         } else {
             $sequencename = $this->sequence_name;
         }
         $field .= ' ' . $sequencename;
         if ($this->sequence_only) {
             /// We only want the field name and sequence name to be printed
             /// so, calculate it and return
             $sql = $this->getEncQuoted($xmldb_field->getName()) . ' ' . $sequencename;
             return $sql;
         }
     }
     return $field;
 }

 /**
  * Given one xmldb_table and one xmldb_field, return the SQL statements needed to alter the field in the table.
  *
  * @param xmldb_table $xmldb_table The table related to $xmldb_field.
  * @param xmldb_field $xmldb_field The instance of xmldb_field to create the SQL from.
  * @param string $skip_type_clause The type clause on alter columns, NULL by default.
  * @param string $skip_default_clause The default clause on alter columns, NULL by default.
  * @param string $skip_notnull_clause The null/notnull clause on alter columns, NULL by default.
  * @return string The field altering SQL statement.
  */
 public function getAlterFieldSQL($xmldb_table, $xmldb_field, $skip_type_clause = NULL, $skip_default_clause = NULL, $skip_notnull_clause = NULL)
 {
     $results = array();
     // To store all the needed SQL commands
     // Get the quoted name of the table and field
     $tablename = $xmldb_table->getName();
     $fieldname = $xmldb_field->getName();
     // Take a look to field metadata
     $meta = $this->mdb->get_columns($tablename);
     $metac = $meta[$fieldname];
     $oldmetatype = $metac->meta_type;
     $oldlength = $metac->max_length;
     $olddecimals = empty($metac->scale) ? null : $metac->scale;
     $oldnotnull = empty($metac->not_null) ? false : $metac->not_null;
     //$olddefault = empty($metac->has_default) ? null : strtok($metac->default_value, ':');
     $typechanged = true;
     //By default, assume that the column type has changed
     $lengthchanged = true;
     //By default, assume that the column length has changed
     // Detect if we are changing the type of the column
     if ($xmldb_field->getType() == XMLDB_TYPE_INTEGER && $oldmetatype == 'I' || $xmldb_field->getType() == XMLDB_TYPE_NUMBER && $oldmetatype == 'N' || $xmldb_field->getType() == XMLDB_TYPE_FLOAT && $oldmetatype == 'F' || $xmldb_field->getType() == XMLDB_TYPE_CHAR && $oldmetatype == 'C' || $xmldb_field->getType() == XMLDB_TYPE_TEXT && $oldmetatype == 'X' || $xmldb_field->getType() == XMLDB_TYPE_BINARY && $oldmetatype == 'B') {
         $typechanged = false;
     }
     // If the new field (and old) specs are for integer, let's be a bit more specific differentiating
     // types of integers. Else, some combinations can cause things like MDL-21868
     if ($xmldb_field->getType() == XMLDB_TYPE_INTEGER && $oldmetatype == 'I') {
         if ($xmldb_field->getLength() > 9) {
             // Convert our new lenghts to detailed meta types
             $newmssqlinttype = 'I8';
         } else {
             if ($xmldb_field->getLength() > 4) {
                 $newmssqlinttype = 'I';
             } else {
                 $newmssqlinttype = 'I2';
             }
         }
         if ($metac->type == 'bigint') {
             // Convert current DB type to detailed meta type (our metatype is not enough!)
             $oldmssqlinttype = 'I8';
         } else {
             if ($metac->type == 'smallint') {
                 $oldmssqlinttype = 'I2';
             } else {
                 $oldmssqlinttype = 'I';
             }
         }
         if ($newmssqlinttype != $oldmssqlinttype) {
             // Compare new and old meta types
             $typechanged = true;
             // Change in meta type means change in type at all effects
         }
     }
     // Detect if we are changing the length of the column, not always necessary to drop defaults
     // if only the length changes, but it's safe to do it always
     if ($xmldb_field->getLength() == $oldlength) {
         $lengthchanged = false;
     }
     // If type or length have changed drop the default if exists
     if ($typechanged || $lengthchanged) {
         $results = $this->getDropDefaultSQL($xmldb_table, $xmldb_field);
     }
     // Some changes of type require multiple alter statements, because mssql lacks direct implicit cast between such types
     // Here it is the matrix: http://msdn.microsoft.com/en-us/library/ms187928(SQL.90).aspx
     // Going to store such intermediate alters in array of objects, storing all the info needed
     $multiple_alter_stmt = array();
     $targettype = $xmldb_field->getType();
     if ($targettype == XMLDB_TYPE_TEXT && $oldmetatype == 'I') {
         // integer to text
         $multiple_alter_stmt[0] = new stdClass();
         // needs conversion to varchar
         $multiple_alter_stmt[0]->type = XMLDB_TYPE_CHAR;
         $multiple_alter_stmt[0]->length = 255;
     } else {
         if ($targettype == XMLDB_TYPE_TEXT && $oldmetatype == 'N') {
             // decimal to text
             $multiple_alter_stmt[0] = new stdClass();
             // needs conversion to varchar
             $multiple_alter_stmt[0]->type = XMLDB_TYPE_CHAR;
             $multiple_alter_stmt[0]->length = 255;
         } else {
             if ($targettype == XMLDB_TYPE_TEXT && $oldmetatype == 'F') {
                 // float to text
                 $multiple_alter_stmt[0] = new stdClass();
                 // needs conversion to varchar
                 $multiple_alter_stmt[0]->type = XMLDB_TYPE_CHAR;
                 $multiple_alter_stmt[0]->length = 255;
             } else {
                 if ($targettype == XMLDB_TYPE_INTEGER && $oldmetatype == 'X') {
                     // text to integer
                     $multiple_alter_stmt[0] = new stdClass();
//.........这里部分代码省略.........

 /**
  * Given one xmldb_table and one xmldb_field, return the SQL statements needed to alter the field in the table.
  *
  * PostgreSQL has some severe limits:
  *     - Any change of type or precision requires a new temporary column to be created, values to
  *       be transfered potentially casting them, to apply defaults if the column is not null and
  *       finally, to rename it
  *     - Changes in null/not null require the SET/DROP NOT NULL clause
  *     - Changes in default require the SET/DROP DEFAULT clause
  *
  * @param xmldb_table $xmldb_table The table related to $xmldb_field.
  * @param xmldb_field $xmldb_field The instance of xmldb_field to create the SQL from.
  * @param string $skip_type_clause The type clause on alter columns, NULL by default.
  * @param string $skip_default_clause The default clause on alter columns, NULL by default.
  * @param string $skip_notnull_clause The null/notnull clause on alter columns, NULL by default.
  * @return string The field altering SQL statement.
  */
 public function getAlterFieldSQL($xmldb_table, $xmldb_field, $skip_type_clause = NULL, $skip_default_clause = NULL, $skip_notnull_clause = NULL)
 {
     $results = array();
     // To store all the needed SQL commands
     // Get the normal names of the table and field
     $tablename = $xmldb_table->getName();
     $fieldname = $xmldb_field->getName();
     // Take a look to field metadata
     $meta = $this->mdb->get_columns($tablename);
     $metac = $meta[$xmldb_field->getName()];
     $oldmetatype = $metac->meta_type;
     $oldlength = $metac->max_length;
     $olddecimals = empty($metac->scale) ? null : $metac->scale;
     $oldnotnull = empty($metac->not_null) ? false : $metac->not_null;
     $olddefault = empty($metac->has_default) ? null : $metac->default_value;
     $typechanged = true;
     //By default, assume that the column type has changed
     $precisionchanged = true;
     //By default, assume that the column precision has changed
     $decimalchanged = true;
     //By default, assume that the column decimal has changed
     $defaultchanged = true;
     //By default, assume that the column default has changed
     $notnullchanged = true;
     //By default, assume that the column notnull has changed
     // Detect if we are changing the type of the column
     if ($xmldb_field->getType() == XMLDB_TYPE_INTEGER && $oldmetatype == 'I' || $xmldb_field->getType() == XMLDB_TYPE_NUMBER && $oldmetatype == 'N' || $xmldb_field->getType() == XMLDB_TYPE_FLOAT && $oldmetatype == 'F' || $xmldb_field->getType() == XMLDB_TYPE_CHAR && $oldmetatype == 'C' || $xmldb_field->getType() == XMLDB_TYPE_TEXT && $oldmetatype == 'X' || $xmldb_field->getType() == XMLDB_TYPE_BINARY && $oldmetatype == 'B') {
         $typechanged = false;
     }
     // Detect if we are changing the precision
     if ($xmldb_field->getType() == XMLDB_TYPE_TEXT || $xmldb_field->getType() == XMLDB_TYPE_BINARY || $oldlength == -1 || $xmldb_field->getLength() == $oldlength) {
         $precisionchanged = false;
     }
     // Detect if we are changing the decimals
     if ($xmldb_field->getType() == XMLDB_TYPE_INTEGER || $xmldb_field->getType() == XMLDB_TYPE_CHAR || $xmldb_field->getType() == XMLDB_TYPE_TEXT || $xmldb_field->getType() == XMLDB_TYPE_BINARY || !$xmldb_field->getDecimals() || !$olddecimals || $xmldb_field->getDecimals() == $olddecimals) {
         $decimalchanged = false;
     }
     // Detect if we are changing the default
     if ($xmldb_field->getDefault() === null && $olddefault === null || $xmldb_field->getDefault() === $olddefault) {
         $defaultchanged = false;
     }
     // Detect if we are changing the nullability
     if ($xmldb_field->getNotnull() === $oldnotnull) {
         $notnullchanged = false;
     }
     // Get the quoted name of the table and field
     $tablename = $this->getTableName($xmldb_table);
     $fieldname = $this->getEncQuoted($xmldb_field->getName());
     // Decide if we have changed the column specs (type/precision/decimals)
     $specschanged = $typechanged || $precisionchanged || $decimalchanged;
     // if specs have changed, need to alter column
     if ($specschanged) {
         // Always drop any exiting default before alter column (some type changes can cause casting error in default for column)
         if ($olddefault !== null) {
             $results[] = 'ALTER TABLE ' . $tablename . ' ALTER COLUMN ' . $fieldname . ' DROP DEFAULT';
             // Drop default clause
         }
         $alterstmt = 'ALTER TABLE ' . $tablename . ' ALTER COLUMN ' . $this->getEncQuoted($xmldb_field->getName()) . ' TYPE' . $this->getFieldSQL($xmldb_table, $xmldb_field, null, true, true, null, false);
         // Some castings must be performed explicitly (mainly from text|char to numeric|integer)
         if (($oldmetatype == 'C' || $oldmetatype == 'X') && ($xmldb_field->getType() == XMLDB_TYPE_NUMBER || $xmldb_field->getType() == XMLDB_TYPE_FLOAT)) {
             $alterstmt .= ' USING CAST(' . $fieldname . ' AS NUMERIC)';
             // from char or text to number or float
         } else {
             if (($oldmetatype == 'C' || $oldmetatype == 'X') && $xmldb_field->getType() == XMLDB_TYPE_INTEGER) {
                 $alterstmt .= ' USING CAST(CAST(' . $fieldname . ' AS NUMERIC) AS INTEGER)';
                 // From char to integer
             }
         }
         $results[] = $alterstmt;
     }
     // If the default has changed or we have performed one change in specs
     if ($defaultchanged || $specschanged) {
         $default_clause = $this->getDefaultClause($xmldb_field);
         if ($default_clause) {
             $sql = 'ALTER TABLE ' . $tablename . ' ALTER COLUMN ' . $fieldname . ' SET' . $default_clause;
             // Add default clause
             $results[] = $sql;
         } else {
             if (!$specschanged) {
                 // Only drop default if we haven't performed one specs change
                 $results[] = 'ALTER TABLE ' . $tablename . ' ALTER COLUMN ' . $fieldname . ' DROP DEFAULT';
                 // Drop default clause
             }
//.........这里部分代码省略.........

 /**
  * Given one xmldb_table and one xmldb_field, return the SQL statements needed to alter the field in the table.
  *
  * Oracle has some severe limits:
  *     - clob and blob fields doesn't allow type to be specified
  *     - error is dropped if the null/not null clause is specified and hasn't changed
  *     - changes in precision/decimals of numeric fields drop an ORA-1440 error
  *
  * @param xmldb_table $xmldb_table The table related to $xmldb_field.
  * @param xmldb_field $xmldb_field The instance of xmldb_field to create the SQL from.
  * @param string $skip_type_clause The type clause on alter columns, NULL by default.
  * @param string $skip_default_clause The default clause on alter columns, NULL by default.
  * @param string $skip_notnull_clause The null/notnull clause on alter columns, NULL by default.
  * @return string The field altering SQL statement.
  */
 public function getAlterFieldSQL($xmldb_table, $xmldb_field, $skip_type_clause = NULL, $skip_default_clause = NULL, $skip_notnull_clause = NULL)
 {
     $skip_type_clause = is_null($skip_type_clause) ? $this->alter_column_skip_type : $skip_type_clause;
     $skip_default_clause = is_null($skip_default_clause) ? $this->alter_column_skip_default : $skip_default_clause;
     $skip_notnull_clause = is_null($skip_notnull_clause) ? $this->alter_column_skip_notnull : $skip_notnull_clause;
     $results = array();
     // To store all the needed SQL commands
     // Get the quoted name of the table and field
     $tablename = $this->getTableName($xmldb_table);
     $fieldname = $xmldb_field->getName();
     // Take a look to field metadata
     $meta = $this->mdb->get_columns($xmldb_table->getName());
     $metac = $meta[$fieldname];
     $oldmetatype = $metac->meta_type;
     $oldlength = $metac->max_length;
     // To calculate the oldlength if the field is numeric, we need to perform one extra query
     // because ADOdb has one bug here. http://phplens.com/lens/lensforum/msgs.php?id=15883
     if ($oldmetatype == 'N') {
         $uppertablename = strtoupper($tablename);
         $upperfieldname = strtoupper($fieldname);
         if ($col = $this->mdb->get_record_sql("SELECT cname, precision\n                                                     FROM col\n                                                     WHERE tname = ? AND cname = ?", array($uppertablename, $upperfieldname))) {
             $oldlength = $col->precision;
         }
     }
     $olddecimals = empty($metac->scale) ? null : $metac->scale;
     $oldnotnull = empty($metac->not_null) ? false : $metac->not_null;
     $olddefault = empty($metac->default_value) || strtoupper($metac->default_value) == 'NULL' ? null : $metac->default_value;
     $typechanged = true;
     //By default, assume that the column type has changed
     $precisionchanged = true;
     //By default, assume that the column precision has changed
     $decimalchanged = true;
     //By default, assume that the column decimal has changed
     $defaultchanged = true;
     //By default, assume that the column default has changed
     $notnullchanged = true;
     //By default, assume that the column notnull has changed
     $from_temp_fields = false;
     //By default don't assume we are going to use temporal fields
     // Detect if we are changing the type of the column
     if ($xmldb_field->getType() == XMLDB_TYPE_INTEGER && $oldmetatype == 'I' || $xmldb_field->getType() == XMLDB_TYPE_NUMBER && $oldmetatype == 'N' || $xmldb_field->getType() == XMLDB_TYPE_FLOAT && $oldmetatype == 'F' || $xmldb_field->getType() == XMLDB_TYPE_CHAR && $oldmetatype == 'C' || $xmldb_field->getType() == XMLDB_TYPE_TEXT && $oldmetatype == 'X' || $xmldb_field->getType() == XMLDB_TYPE_BINARY && $oldmetatype == 'B') {
         $typechanged = false;
     }
     // Detect if precision has changed
     if ($xmldb_field->getType() == XMLDB_TYPE_TEXT || $xmldb_field->getType() == XMLDB_TYPE_BINARY || $oldlength == -1 || $xmldb_field->getLength() == $oldlength) {
         $precisionchanged = false;
     }
     // Detect if decimal has changed
     if ($xmldb_field->getType() == XMLDB_TYPE_INTEGER || $xmldb_field->getType() == XMLDB_TYPE_CHAR || $xmldb_field->getType() == XMLDB_TYPE_TEXT || $xmldb_field->getType() == XMLDB_TYPE_BINARY || !$xmldb_field->getDecimals() || !$olddecimals || $xmldb_field->getDecimals() == $olddecimals) {
         $decimalchanged = false;
     }
     // Detect if we are changing the default
     if ($xmldb_field->getDefault() === null && $olddefault === null || $xmldb_field->getDefault() === $olddefault || "'" . $xmldb_field->getDefault() . "'" === $olddefault) {
         //Equality with quotes because ADOdb returns the default with quotes
         $defaultchanged = false;
     }
     // Detect if we are changing the nullability
     if ($xmldb_field->getNotnull() === $oldnotnull) {
         $notnullchanged = false;
     }
     // If type has changed or precision or decimal has changed and we are in one numeric field
     //     - create one temp column with the new specs
     //     - fill the new column with the values from the old one
     //     - drop the old column
     //     - rename the temp column to the original name
     if ($typechanged || ($oldmetatype == 'N' || $oldmetatype == 'I') && ($precisionchanged || $decimalchanged)) {
         $tempcolname = $xmldb_field->getName() . '___tmp';
         // Short tmp name, surely not conflicting ever
         if (strlen($tempcolname) > 30) {
             // Safeguard we don't excess the 30cc limit
             $tempcolname = 'ongoing_alter_column_tmp';
         }
         // Prevent temp field to have both NULL/NOT NULL and DEFAULT constraints
         $skip_notnull_clause = true;
         $skip_default_clause = true;
         $xmldb_field->setName($tempcolname);
         // Drop the temp column, in case it exists (due to one previous failure in conversion)
         // really ugly but we cannot enclose DDL into transaction :-(
         if (isset($meta[$tempcolname])) {
             $results = array_merge($results, $this->getDropFieldSQL($xmldb_table, $xmldb_field));
         }
         // Create the temporal column
         $results = array_merge($results, $this->getAddFieldSQL($xmldb_table, $xmldb_field, $skip_type_clause, $skip_type_clause, $skip_notnull_clause));
         // Copy contents from original col to the temporal one
         // From TEXT to integer/number we need explicit conversion
//.........这里部分代码省略.........