Add the discriminator column.

@param string $column
@param string $type
@param int    $length

@return Inheritance
331698
public function column($column, $type = 'string', $length = 255)
    {
        $this->builder->setDiscriminatorColumn($column, $type, $length);

        return $this;
    }
171833
public function addColumn($acronym, $type = null, array $options = [])
    {
        if (in_array($acronym, $this->reservedColumnAcronyms)) {
            throw new ReservedColumnAcronymException($acronym);
        }

        if ($type === null) {
            $type = Column::class;
        }

        $column = new $type($acronym, $options);

        // only DoctrineTable can sort nested properties. Therefore disable them for other tables.
        if (!$this instanceof DoctrineTable && $column instanceof SortableColumnInterface && $column->isSortable()) {
            if (strpos($column->getSortExpression(), '.') !== false) {
                $column->setSortable(false);
            }
        }

        if ($column instanceof TemplateableColumnInterface) {
            $column->setTemplating($this->templating);
        }

        if ($column instanceof SortableColumnInterface) {
            $column->setTableIdentifier($this->getIdentifier());
        }

        if ($column instanceof FormattableColumnInterface) {
            $column->setFormatterManager($this->formatterManager);
        }

        $this->columns->set($acronym, $column);

        return $this;
    }
304956
public <T> DiscriminatorJdbcBuilder<T> newDiscriminator(String column) {
        ignorePropertyNotFound();
        addColumnDefinition(column, FieldMapperColumnDefinition.<JdbcColumnKey>ignoreDefinition());
        return new DiscriminatorJdbcBuilder<T>(column, this);
    }
614726
public function column($name, $type = null, $options = [])
    {
        return $this->addColumn($name, $type, $options);
    }
402089
public function addColumn($columnName, $type = null, $options = [])
    {
        $column = new Column();
        $column->setName($columnName);
        $column->setType($type);
        $column->setOptions($options);

        $column->setTable($this);

        parent::addColumn($column);

        return $column;
    }
1195103
public function addEnclosure($url, $type = '', $length = '')
    {
        if (!$this->offsetExists('enclosure')) {
            $enclosure = array();
        } else {
            $enclosure = $this->offsetGet('enclosure');
        }
        $enclosure[] = array('url' => $url,
                             'type' => $type,
                             'length' => $length);
        $this->offsetSet('enclosure', $enclosure);
        return $this;
    }
1257189
public function addColumn($type, $column, array $parameters = array())
	{
		// check against existing
		if(!$this->builder->hasColumn($this->table, $column))
			return parent::addColumn($type, $column, $parameters);

		// else probably compare and do some alteration
	}
1191919
public RestQueryResult addColumn( String name,
                                      String type ) {
        if (!StringUtil.isBlank(name)) {
            columns.put(name, type);
        }
        return this;
    }
38247
public function addType($type)
    {
        if (is_string($type)) {
            $type = array($type);
        }

        foreach($type as $typ) {
            if (defined('self::' . strtoupper($typ)) && !in_array($typ, $this->_type)) {
                $this->_type[] = $typ;
            }

            if (($typ == self::ALL)) {
                $this->_type = array_keys($this->_cardLength);
            }
        }

        return $this;
    }
242989
public function addIndex($type, ...$columns) {
        if (empty($columns)) {
            throw new \InvalidArgumentException("An index must contain at least one column.", 500);
        }

        $type = strtolower($type);

        // Look for a current index row.
        $currentIndex = null;
        foreach ($this->indexes as $i => $index) {
            if ($type !== $index['type']) {
                continue;
            }

            if ($type === Db::INDEX_PK || array_diff($index['columns'], $columns) == []) {
                $currentIndex =& $this->indexes[$i];
                break;
            }
        }

        if ($currentIndex) {
            $currentIndex['columns'] = $columns;
        } else {
            $indexDef = [
                'type' => $type,
                'columns' => $columns,
            ];
            $this->indexes[] = $indexDef;
        }

        return $this;
    }
1096729
protected void addType(final Long _typeId)
    {
        if (!this.types.contains(_typeId)) {
            this.types.add(_typeId);
            setDirty();
        }
    }
739055
public function addAllowedType($type)
    {
        if (!in_array(strtolower($type), $this->allowedTypes)) {
            $this->allowedTypes[] = strtolower($type);
        }
        return $this;
    }
891991
protected function newGenerator($type, $length = null)
	{
		$generator = GeneratorFactory::create($type)->mutate($this)->length($length ?: $this->length);

		if (isset($this->prefix)) {
			$generator->prefix($this->prefix);
		}

		if (isset($this->suffix)) {
			$generator->suffix($this->suffix);
		}

		return $generator;
	}
1335460
public function bindParam($column, &$param, $type = null)
    {
        if ($type === null) :
            $this->_statement->bindParam($column, $param);
        else :
            $this->_statement->bindParam($column, $param, $type);
        endif;
    }
402950
public function addColumn(Column $column)
    {
        $this->columns[] = $column;

        if ($column instanceof ColumnInput) {
            $this->append_empty_row = true;
            $this->setWidth('100%');
        } elseif ($column instanceof ColumnOrder && $column->isDragable()) {
            $this->dragable = true;
        } elseif ($column instanceof ColumnTree && !$this->tree) {
            $this->tree_node_id = \count($this->columns) - 1;
            $this->tree = true;
        } elseif ($column instanceof ColumnTree && $this->tree) {
            throw new LogicException('May be only one ColumnTree');
        }

        return $this;
    }
337357
public function addColumn($column, $type)
    {
        $this->append(sprintf(' ADD COLUMN %s %s', $this->quote($column), $type));
        return $this;
    }
667936
public function addSorting($column, $type)
    {
        $availableSortTypes = [self::SORT_ASC, self::SORT_DESC];
        if (!in_array($type, $availableSortTypes)) {
            throw new \Exception(sprintf('Wrong sort type: "%s". Supported types: [%s]', $type, implode(',', $availableSortTypes)));
        }

        $this->sortParams[$column] = $type;

        return $this;
    }