{@inheritDoc}
@see \n2n\persistence\meta\structure\ColumnFactory::createIntegerColumn()
@return IntegerColumn
1564
public function createIntegerColumn(string $name, int $size, bool $signed = true): IntegerColumn {
		$column = new SqliteIntegerColumn($name);
		$this->table->addColumn($column);
		return $column;
	}
1201765
public function index() : ColumnMappingDefiner
    {
        return new ColumnMappingDefiner(
            function (IColumn $column) {
                $this->column($column);
                $this->indexComponentIdMap[] = $column->getComponentId();
            },
            function (string $componentId) {
                $this->indexComponentIdMap[] = $componentId;
            }
        );
    }
847513
public function increment(string $column, int $value = 1)
    {
        $instance = $this->updateQueryInstance();

        $instance->updateQuery()->increment($column, $value);

        return $instance;
    }
1330219
public function createColumnFactory(): ColumnFactory {
		if (!($this->columnFactory)) {
			$this->columnFactory = new OracleColumnFactory($this);
		}
		return $this->columnFactory;
	}
1025777
public function smallIncrements($columnName)
    {
        $column = $this->smallInteger($columnName, true, true);
        $this->primary($columnName);

        return $column;
    }
500792
public function getIntegerPart()
	{
		if ( ! $this->getIsDecimal() ) return $this->_value;
		return substr( $this->_value, 0, strpos( $this->_value, "." ) );
	}
347057
public function int($column, $length = null)
    {
        return $this->addColumn($column, self::TYPE_INT, array('length' => $length));
    }
16639
public java.math.BigInteger getBigInteger(String column) {
		return (java.math.BigInteger)getColumns().get(column);
	}
1374361
public static <K> NumberMap<K, Integer> newIntegerMap() {
		return new NumberMap<K, Integer>() {
			@Override
			public void add(K key, Integer addend) {
				put(key, containsKey(key) ? (get(key) + addend) : addend);
			}
			@Override
			public void sub(K key, Integer subtrahend) {
				put(key, (containsKey(key) ? get(key) : 0) - subtrahend);
			}
		};
	}
1269278
public function bigInteger($column, $autoIncrement = false, $unsigned = false)
    {
        return $this->addColumn('bigInteger', $column, compact('autoIncrement', 'unsigned'));
    }
1102736
public function smallInt($column, $length = null)
    {
        return $this->addColumn($column, self::TYPE_SMALL_INT, array('length' => $length));
    }
1213792
public function sqrt() : BigInteger
    {
        if ($this->value[0] === '-') {
            throw new NegativeNumberException('Cannot calculate the square root of a negative number.');
        }

        $value = Calculator::get()->sqrt($this->value);

        return new BigInteger($value);
    }
296206
public BigInteger getInternalBigInteger(ColumnInformation columnInfo) throws SQLException {
    if (lastValueWasNull()) {
      return null;
    }
    switch (columnInfo.getColumnType()) {
      case BIT:
        return BigInteger.valueOf((long) buf[pos]);
      case TINYINT:
        return BigInteger.valueOf((long)
            (columnInfo.isSigned() ? buf[pos] : (buf[pos] & 0xff)));
      case SMALLINT:
      case YEAR:
        short valueShort = (short) ((buf[pos] & 0xff) | ((buf[pos + 1] & 0xff) << 8));
        return BigInteger
            .valueOf((long) (columnInfo.isSigned() ? valueShort : (valueShort & 0xffff)));
      case INTEGER:
      case MEDIUMINT:
        int valueInt = ((buf[pos] & 0xff)
            + ((buf[pos + 1] & 0xff) << 8)
            + ((buf[pos + 2] & 0xff) << 16)
            + ((buf[pos + 3] & 0xff) << 24));
        return BigInteger.valueOf(((columnInfo.isSigned()) ? valueInt
            : (valueInt >= 0) ? valueInt : valueInt & 0xffffffffL));
      case BIGINT:
        long value = ((buf[pos] & 0xff)
            + ((long) (buf[pos + 1] & 0xff) << 8)
            + ((long) (buf[pos + 2] & 0xff) << 16)
            + ((long) (buf[pos + 3] & 0xff) << 24)
            + ((long) (buf[pos + 4] & 0xff) << 32)
            + ((long) (buf[pos + 5] & 0xff) << 40)
            + ((long) (buf[pos + 6] & 0xff) << 48)
            + ((long) (buf[pos + 7] & 0xff) << 56)
        );
        if (columnInfo.isSigned()) {
          return BigInteger.valueOf(value);
        } else {
          return new BigInteger(1, new byte[]{(byte) (value >> 56),
              (byte) (value >> 48), (byte) (value >> 40), (byte) (value >> 32),
              (byte) (value >> 24), (byte) (value >> 16), (byte) (value >> 8),
              (byte) value});
        }
      case FLOAT:
        return BigInteger.valueOf((long) getInternalFloat(columnInfo));
      case DOUBLE:
        return BigInteger.valueOf((long) getInternalDouble(columnInfo));
      case DECIMAL:
      case OLDDECIMAL:
        return BigInteger.valueOf(getInternalBigDecimal(columnInfo).longValue());
      default:
        return new BigInteger(new String(buf, pos, length, StandardCharsets.UTF_8));
    }
  }
845800
@Override
  public final Integer getInteger(final String pColumnName) throws Exception {
    int columnIndex = this.resultSet.getColumnIndex(pColumnName);
    Integer result = null;
    if (!this.resultSet.isNull(columnIndex)) {
      result = this.resultSet.getInt(columnIndex);
    }
    return result;
  }
1235439
public function integer($column, $autoIncrement = false, $unsigned = false) {
        return $this->addColumn('INTEGER', $column, compact('autoIncrement', 'unsigned'));
    }
663574
public function createTable(ModelInterface $model)
    {
        $i = 0;

        $model->setConnection($this->connection);

        $schemaManager = $this->connection->getSchemaManager();
        $builder = $this->getQueryBuilder();
        $tableName = TableNameResolver::getTableName($model->tableName());

        $columns = [];
        $indexes = [];

        foreach ($model->getMeta()->getFields() as $name => $field) {
            $field->setModel($model);

            if ($field instanceof ManyToManyField) {
                $field->setConnection($this->connection);

                /* @var $field \Mindy\Orm\Fields\ManyToManyField */
                if (null === $field->through) {
                    $fieldTableName = TableNameResolver::getTableName($field->getTableName());
                    if (false === $this->hasTable($fieldTableName)) {
                        $fieldTable = new Table(
                            $fieldTableName,
                            $field->getColumns()
                        );
                        $schemaManager->createTable($fieldTable);
                        $i += 1;
                    }
                }
            } else {
                $column = $field->getColumn();
                if (empty($column)) {
                    continue;
                }

                $columns[] = $column;
                $indexes = array_merge($indexes, $field->getSqlIndexes());
            }
        }

        if (false === $this->hasTable($tableName)) {
            $table = new Table($tableName, $columns, []);
            $table->setPrimaryKey($model->getPrimaryKeyName(true), 'primary');
            $schemaManager->createTable($table);

            $i += 1;
        }

        return $i;
    }
370953
public static Token newInteger(String text, int startLine, int startColumn) {
        return new Token(Types.INTEGER_NUMBER, text, startLine, startColumn);
    }