How to Store a Large (10 Digits) Integer

How to store a large (10 digits) integer?

Your concrete example could be stored in long (or java.lang.Long if this is necessary).

If at any point you need bigger numbers, you can try
java.math.BigInteger (if integer), or java.math.BigDecimal (if decimal)

How should I store a extremely large Data Type

You can create and edit BigInteger In java, e.g.:

BigInteger bigInteger = new BigInteger("3");
bigInteger = bigInteger.pow(600);
bigInteger = bigInteger.add(new BigInteger("20"));
bigInteger = bigInteger.subtract(new BigInteger("20"));
bigInteger = bigInteger.multiply(new BigInteger("20"));
bigInteger = bigInteger.divide(new BigInteger("20"));

And you can get any part of BigInteger as an Integer, e.g.:

int i = Integer.parseInt(bigInteger.toString().substring(3, 8));

I hope this will help you.

how to store a 10 digit number into sql bigint datatype?

Maximum value that can be stored in MySQL INT datatype is 2147483647.

MySQL will silently truncate larger values down to the maximum supported value.

This is expected (i.e. documented) behavior.

Reference: https://dev.mysql.com/doc/refman/5.7/en/integer-types.html

datataype     maximum signed value
---------     --------------------
TINYINT                        127
SMALLINT                     32767
MEDIUMINT                   388607
INT                     2147483647
BIGINT                      2^63-1

If we are seeing this behavior storing to a BIGINT column, then somewhere in the code path, the value got converted to INT datatype, which truncated the value, before the value was assigned to the BIGINT column. This could occur as the return from a function call, or in an assignment of the value in a TRIGGER, et al.

It's not possible to more precisely diagnose the issue with the information provided.

---

How to store a value to a BIGINT column?

We can send a string literal in a SQL statement. As a demonstration, twelve decimal digits

 CREATE TABLE foo (mycol BIGINT); 
 INSERT INTO foo (mycol) VALUES ('987645312745');
 SELECT mycol FROM foo;

         mycol
 -------------
  987645312745

Storing and printing 10+ digit integer in c++

long long can hold up to 9223372036854775807. Use something like gmp if you need larger.

Why can an int hold a 10 digits number but can't handle 9 digits of another integer?

It has nothing to do with the number of "places" in base 10 or, if you prefer, the length of the number when you write it out (again, in base 10). The most basic reason for the limitation is that computers store numbers (and everything else) in terms of bits and bytes, which means they work in base 2.

An int in c is a 4-byte (32-bit) datatype. It can store numbers in the range -2,147,483,648 (-2³¹) to 2,147,483,647 (2³¹ - 1) if the int is signed or 0 to 4,294,967,295 (2³²-1) if it is not.

Either way, 1234567891 is in the range that fits in 4 bytes, but 9999999999 and 12345678912 are not.

---

Note: I recognize the spec allows for an int to be 2 bytes, but the behavior OP describes is only possible if OP is using an implementation in which an int is 4 bytes.

---

Related Topics