{@inheritDoc}
@see \n2n\persistence\meta\structure\ColumnFactory::createFixedPointColumn()
@return FixedPointColumn
772606
public function createFixedPointColumn(string $name, int $numIntegerDigits, int $numDecimalDigits): FixedPointColumn {
		$fixedPointColumn = new CommonFixedPointColumn($name, $numIntegerDigits, $numDecimalDigits);
		$this->table->addColumn($fixedPointColumn);
		return $fixedPointColumn;
	}
371456
public function createInstance()
    {
        switch ($this->method) {
            case 'addBigIntegerColumn':
            case 'addBinaryColumn':
            case 'addBooleanColumn':
            case 'addDateColumn':
            case 'addDateTimeColumn':
            case 'addDecimalColumn':
            case 'addFloatColumn':
            case 'addIntegerColumn':
            case 'addSmallIntegerColumn':
            case 'addStringColumn':
            case 'addTextColumn':
            case 'addTimeColumn':
                $namespace = 'Rentgen\\Database\\Column\\';
                $class = $namespace . ltrim($this->method, 'add');
                $options = isset($this->params[1]) ? $this->params[1] : array();

                if ('addStringColumn' === $this->method && !isset($options['limit'])) {
                    $options['limit'] = 255;
                }
                $column = new $class($this->params[0], $options);
                break;
            case 'addCustomColumn':
                $options = isset($this->params[2]) ? $this->params[2] : [];
                $column = new CustomColumn($this->params[0], $this->params[1], $options);
                break;
            default:
                throw new \Exception(sprintf("Unsupported method " . $this->method));
        }

        if (isset($options['comment'])) {
            $column->setDescription($options['comment']);
        }

        return $column;
    }
692632
public function getColumn()
    {
        $type = $this->getSqlType();
        if ($type) {
            return new Column($this->getAttributeName(), $type, $this->getSqlOptions());
        }
    }
982591
public function setPosition($v)
    {
        if ($v !== null) {
            $v = (int) $v;
        }

        if ($this->position !== $v) {
            $this->position = $v;
            $this->modifiedColumns[LineageTableMap::COL_POSITION] = true;
        }

        return $this;
    }
127949
public function addColumn(Column $column)
    {
        if (array_key_exists((string)$column, $this->columns)) {
            throw new \InvalidArgumentException("Column with label '$column' already exists!");
        }
        $this->columns[(string)$column] = $column;

        return $this;
    }
332577
protected static function buildColumn($data)
    {
        $counter = 0;
        $insertQuery = "";
        $arraySize = count($data);

        foreach ($data as $key => $value)
        {
            $counter++;
            $insertQuery .= self::sanitize($key);
            if($arraySize > $counter)
                $insertQuery .= ", ";
        }
        return $insertQuery;
    }
668175
public static function build(array $configuration = []): ?TableColumn
    {
        if (!array_key_exists('type', $configuration)) {
            throw new InvalidConfigException('Configuration for TableColumnFactory is missing "type" key.');
        }

        switch ($configuration['type']) {
            case Schema::TYPE_PK:
                return new TableColumnPK($configuration);

            case Schema::TYPE_UPK:
                return new TableColumnUPK($configuration);

            case Schema::TYPE_BIGPK:
                return new TableColumnBigPK($configuration);

            case Schema::TYPE_UBIGPK:
                return new TableColumnBigUPK($configuration);

            case Schema::TYPE_CHAR:
                return new TableColumnChar($configuration);

            case Schema::TYPE_STRING:
                return new TableColumnString($configuration);

            case Schema::TYPE_TEXT:
                return new TableColumnText($configuration);

            case Schema::TYPE_TINYINT:
                return new TableColumnTinyInt($configuration);

            case Schema::TYPE_SMALLINT:
                return new TableColumnSmallInt($configuration);

            case Schema::TYPE_INTEGER:
                return new TableColumnInt($configuration);

            case Schema::TYPE_BIGINT:
                return new TableColumnBigInt($configuration);

            case Schema::TYPE_BINARY:
                return new TableColumnBinary($configuration);

            case Schema::TYPE_FLOAT:
                return new TableColumnFloat($configuration);

            case Schema::TYPE_DOUBLE:
                return new TableColumnDouble($configuration);

            case Schema::TYPE_DATETIME:
                return new TableColumnDateTime($configuration);

            case Schema::TYPE_TIMESTAMP:
                return new TableColumnTimestamp($configuration);

            case Schema::TYPE_TIME:
                return new TableColumnTime($configuration);

            case Schema::TYPE_DATE:
                return new TableColumnDate($configuration);

            case Schema::TYPE_DECIMAL:
                return new TableColumnDecimal($configuration);

            case Schema::TYPE_BOOLEAN:
                return new TableColumnBoolean($configuration);

            case Schema::TYPE_MONEY:
                return new TableColumnMoney($configuration);

            case Schema::TYPE_JSON:
                return new TableColumnJson($configuration);

            default:
                throw new InvalidConfigException("Unsupported schema type '{$configuration['type']}' for TableColumnFactory.");
        }
    }
1024338
public static <T> TupleDomain<T> fromFixedValues(Map<T, NullableValue> fixedValues)
    {
        return TupleDomain.withColumnDomains(fixedValues.entrySet().stream()
                .collect(toLinkedMap(
                        Map.Entry::getKey,
                        entry -> {
                            Type type = entry.getValue().getType();
                            Object value = entry.getValue().getValue();
                            return value == null ? Domain.onlyNull(type) : Domain.singleValue(type, value);
                        })));
    }
476916
public static function incrementingInt(string $name) : Column
    {
        return new Column($name, self::primaryKeyType()->autoIncrement(), true);
    }
512297
protected function tableColumn($column)
    {
        if (is_null($this->table)) {
            $this->setTable();
        }

        return new Column($this->context, $this->table, $column);
    }
451957
function setColumns($columns) {
		$this->columns = array();

		if ($columns === null) {
			return $this;
		}

		if (is_string($columns)) {
			return $this->addColumn($columns);
		}

		foreach ($columns as $alias => &$column) {
			$this->addColumn($column, is_int($alias) ? null : $alias);
		}
		return $this;
	}
1156607
public function setNpcheckpoints($v)
    {
        if ($v !== null) {
            $v = (int) $v;
        }

        if ($this->npcheckpoints !== $v) {
            $this->npcheckpoints = $v;
            $this->modifiedColumns[MapTableMap::COL_NPCHECKPOINTS] = true;
        }

        return $this;
    }
677046
public function withColumnsButIgnoringConstraints(array $columns) : Table
    {
        if ($this->columns === $columns) {
            return $this;
        }

        return new self($this->name, $columns);
    }
992197
public function setEndpoint($v)
    {
        if ($v !== null) {
            $v = (string) $v;
        }

        if ($this->endpoint !== $v) {
            $this->endpoint = $v;
            $this->modifiedColumns[SourceTableMap::COL_ENDPOINT] = true;
        }

        return $this;
    }
880102
public function addCol($width=NULL) {
		$colCount=$this->colCount() + 1;
		$this->setColsCount($colCount, true, $width);
		if ($this->hasOnlyCols($this->count()))
			return $this->content[$colCount - 1];
		return $this;
	}
1097401
private function insert() {
        if ($this->isPersistent()) throw new RuntimeException('Cannot insert already persistent '.$this);

        // pre-processing hook
        if ($this->beforeInsert() !== true)
            return $this;

        $mapping = $this->dao()->getMapping();

        // collect column values
        $values = [];
        foreach ($mapping['columns'] as $column => $property) {
            $values[$column] = $this->getPhysicalValue($column);
        };

        // perform insertion
        $id = $this->doInsert($values);
        $this->_modified = false;

        // assign the returned identity value
        $idName = $mapping['identity']['name'];
        if ($this->$idName === null)
            $this->$idName = $id;

        // post-processing hook
        $this->afterInsert();
        return $this;
    }
1198894
public function createFloatingPointColumn(string $name, int $size): FloatingPointColumn {
		$floatingPointColumn = new CommonFloatingPointColumn($name, $size);
		$this->table->addColumn($floatingPointColumn);
		return $floatingPointColumn;
	}