Tagged articles
BIGINT
26 articles · Page 1 of 1
This article explains how PHP's floating‑point precision pitfalls can be eliminated by using TypePHP's built‑in high‑precision types—Decimal, BigInt, and BigFloat—through a complete order‑total example, detailed type‑system overview, inference rules, conversion methods, and performance‑critical tips.
BIGINTDecimalHigh-Precision Arithmetic
0 likes · 11 min read

An INT auto‑increment primary key can exhaust its 2‑31‑1 limit in just 80 days under 10 M QPS, so the article explains how ID consumption is amplified, the high cost of migrating to BIGINT, the single‑point bottleneck of auto‑increment, and compares Snowflake, segment, UUIDv7, and Redis distributed ID solutions.
BIGINTMySQLRedis
0 likes · 18 min read

A backend engineer discovers that a massive MySQL table’s auto‑increment INT primary key reached its maximum value, causing insert failures, and walks through detailed analysis, three remediation options—including switching to BIGINT, redesigning IDs, and sharding—plus practical scripts, performance measurements, and lessons learned about concurrency and schema design.
BIGINTConcurrencyDatabase Migration
0 likes · 10 min read

When a MySQL table's auto‑increment primary key approaches its maximum value, you can avoid failures by converting the column to BIGINT, switching to UUIDs, using segmented ID generators, composite keys, adjusting the increment step, or applying database sharding.
BIGINTDatabase DesignID Exhaustion
0 likes · 6 min read

The article recounts a MySQL production incident where an INT auto‑increment column reached its maximum value, causing insert failures, and walks through analysis, three remediation options, a stored‑procedure cleanup, a conversion to BIGINT, performance monitoring, and lessons on concurrency and schema design.
BIGINTConcurrencyDatabase Performance
0 likes · 9 min read

When a backend generates 19‑digit Snowflake IDs, JavaScript’s Number type truncates the trailing digits, causing add operations to work but delete or update actions to fail, and this article explains the root cause and four practical solutions.
AxiosBIGINTJavaScript
0 likes · 7 min read

A massive MySQL table ran out of INT auto‑increment IDs due to high concurrency, leading to insert failures; the article analyzes the root cause, evaluates three remediation strategies, and details the eventual migration to BIGINT with performance monitoring and code snippets.
BIGINTConcurrencyMySQL
0 likes · 9 min read

The article recounts a real‑world incident where a massive MySQL table exceeded the INT auto‑increment limit, causing insert failures, and walks through analysis, three remediation strategies—including converting to BIGINT, using distributed IDs, and sharding—plus practical SQL scripts and performance insights for handling billions of rows.
BIGINTDatabase MigrationINT overflow
0 likes · 9 min read

This article recounts a real‑world MySQL incident where the auto‑increment INT overflowed after billions of rows, explores why the ID limit was reached, evaluates three remediation strategies—including switching to BIGINT, distributed IDs, and sharding—and shares practical SQL scripts and performance insights.
BIGINTMySQLStored Procedure
0 likes · 9 min read

A massive MySQL table reached the INT auto‑increment ceiling, causing insert failures; the article details how the issue was identified, explores three remediation strategies—including converting the column to BIGINT, redesigning IDs, and sharding—shows stored‑procedure scripts, performance monitoring, and practical lessons on schema design and multithreaded batch processing.
BIGINTMySQLauto-increment
0 likes · 8 min read

A senior architect investigates a missing device error caused by MySQL auto‑increment IDs reaching the 32‑bit integer limit, analyzes the overflow issue, evaluates three remediation strategies—including converting the column to BIGINT, adopting distributed IDs, or sharding the database—and shares practical code snippets and performance insights for large‑scale data migrations.
BIGINTDatabase MigrationMySQL
0 likes · 11 min read


ITPUBJun 27, 2025 · Fundamentals
This article explains the special cases where the JavaScript expression num === num - 1 evaluates to true, covering Infinity, numbers beyond the safe integer range, how to detect unsafe values, and practical solutions using Number.isSafeInteger, BigInt, bignumber.js, and a custom big‑integer addition implementation.
Arbitrary PrecisionBIGINTInfinity
0 likes · 8 min read

The article explains why using a VARCHAR(20) column to store billions of phone numbers is safer and more flexible than INT or BIGINT, covering range limits, data integrity, query convenience, interview expectations, and common pitfalls such as insufficient field length, charset issues, missing indexes, and lack of encryption.
BIGINTSQLdata integrity
0 likes · 10 min read

The article examines an interview question about storing 2 billion phone numbers, explains why int cannot hold 11‑digit numbers, advocates using VARCHAR(20) for flexibility and data integrity, and outlines common pitfalls and best practices for database design.
BIGINTDatabase DesignMySQL
0 likes · 8 min read

When designing a schema for two‑billion phone numbers, use a VARCHAR(20) column with utf8mb4 Unicode, a unique index, and proper validation/encryption rather than a 32‑bit INT, because strings preserve leading zeros, international prefixes, extensions, and support business extensibility, fault tolerance, and future changes.
BIGINTDatabase DesignInterview
1 likes · 7 min read

While MySQL INT and BIGINT auto‑increment columns usually suffice, this article explains their numeric limits, calculates how many records each can store over time (e.g., at 100 inserts per second), and provides practical steps to switch from INT to BIGINT safely.
BIGINTMySQLauto-increment
0 likes · 6 min read

This article introduces several relatively obscure yet practical ES6 features—including Object.entries/Object.fromEntries, Symbol, WeakMap/WeakSet, Promise.allSettled, BigInt, Array.of/Array.from, and the .at and flat methods—explaining their purpose and providing code examples for each.
BIGINTES6JavaScript
0 likes · 8 min read

This article evaluates how MySQL stores time using datetime, timestamp, and bigint fields by inserting 500,000 records and measuring query, grouping, and sorting speeds, concluding that bigint generally offers the best performance for time‑range operations while timestamp saves space when no manipulation is needed.
BIGINTMySQLtimestamp
0 likes · 5 min read

This article evaluates how MySQL handles time data stored as datetime, timestamp, and bigint by inserting half a million records and measuring query, grouping, and sorting speeds, concluding that bigint generally offers the best performance for time‑range operations.
BIGINTDATETIMEMySQL
0 likes · 6 min read

This article benchmarks MySQL's datetime, timestamp, and bigint columns by inserting 500,000 rows and measuring query, group‑by, and order‑by performance, concluding that bigint generally offers the best speed for time‑based operations while timestamp saves space for static timestamps.
BIGINTDATETIMESQL
0 likes · 6 min read

This article explains MySQL AUTO_INCREMENT behavior, demonstrates creating tables with unsigned int primary keys, shows how to set and inspect the AUTO_INCREMENT value, discusses its maximum limits, and recommends using bigint or explicit primary keys to avoid overflow and duplicate‑key errors.
BIGINTDatabase DesignMySQL
0 likes · 4 min read

This article explains how MySQL integer auto‑increment primary keys can reach their maximum value, the resulting duplicate‑key errors, and how using BIGINT or understanding InnoDB's internal row_id behavior can prevent data loss or crashes.
BIGINTDatabase LimitsPrimary Key
0 likes · 6 min read

This article reviews the most useful ES2020 (ES11) JavaScript features—including private class fields, Promise.allSettled, the BigInt type, nullish coalescing (??), optional chaining (?.), dynamic import, String.prototype.matchAll, globalThis, and module namespace exports—explaining their syntax, behavior, and practical code examples.
BIGINTDynamicImportES2020
0 likes · 12 min read

This article traces JavaScript’s evolution, covering the enrichment of prototype methods, standardization of classes and modules, the rise of asynchronous patterns like callbacks, promises, generators, async/await, and modern syntax features such as block scope, symbols, BigInt, reflection, and useful syntactic sugar.
BIGINTES6JavaScript
0 likes · 28 min read

This article explains why MySQL auto‑increment primary keys can reach their limit, shows how switching from INT to BIGINT prevents overflow, and reviews three online schema‑change methods—including native ALTER, pt‑osc, and gh‑ost—plus considerations for triggers, foreign keys, and master‑slave setups.
BIGINTMySQLOnline Schema Change
0 likes · 8 min read

Node.js 10 LTS introduces major updates such as native HTTP/2 support, BigInt, recursive directory creation, CLI flag auto‑completion, Windows installer improvements, V8‑based code coverage, deprecated Buffer constructors, and experimental Worker Threads, while also upgrading OpenSSL and adding PEM‑level encryption.
BIGINTHTTP/2LTS
0 likes · 11 min read
