After upgrading from MySQL 5.7 to 8.0, a client observed that ORDER BY queries on wide SELECTs became dramatically slower because MySQL 8.0 deprecated the max_length_for_sort_data setting, causing the optimizer to perform full‑field sorting instead of index‑based sorting; adding an index on the ordered column restores performance.
This article explains why the SQL IN and NOT IN operators often cause performance bottlenecks and subtle bugs, demonstrates real‑world examples with large tables, shows how NULL values can produce wrong results, and recommends using EXISTS, NOT EXISTS or JOINs for reliable and efficient queries.
The article explains how PostgreSQL’s MVCC model, tuple visibility, and 32‑bit transaction ID wrap‑around can cause “sudden death” of old rows, why billions of old transactions may render data invisible, and how vacuuming and freezing prevent catastrophic database failures.
UUIDs offer global uniqueness for distributed systems but can hurt insertion speed and increase storage, especially with random UUIDv4 keys; this article explains UUID basics, performance drawbacks, and evaluates alternatives like UUIDv7, auto‑increment integers, and ULID to help you choose the right identifier for your database.
This article explains how to connect to a MySQL database using mysqli in PHP, execute a SELECT query, and retrieve each row with the mysqli_fetch_assoc function, providing complete example code and notes on handling results and closing the connection.
This article introduces ten powerful MySQLi functions—including prepared statements, parameter binding, result retrieval, batch queries, transaction control, charset setting, and connection monitoring—that enhance PHP developers’ ability to write secure, efficient, and maintainable code when interacting with MySQL databases.
This article explains typical sharding strategies—hash, range, and middle‑table—describes SDK, Proxy, and Sidecar middleware forms, and presents several pagination optimization techniques such as global query rewriting, average pagination, disabling cross‑page queries, secondary queries, and using intermediate tables to improve performance in distributed databases.
This article explains how to improve MySQL query performance by optimizing ORDER BY, GROUP BY, and LIMIT operations, covering index usage, file‑sort algorithms, covering indexes, prefix indexes, and practical code examples for large‑scale data sets.
Redis offers three persistence options—AOF, which logs every write command; RDB, which creates periodic snapshots; and hybrid persistence, which combines both—to balance data safety, recovery speed, file size, and performance, with configurable settings for sync policies, rewrite processes, and compression.
Redis Cluster distributes data using 16,384 hash slots calculated via CRC16, a design that offers flexible slot allocation, simpler data migration, and better performance compared to traditional consistent hashing, and this article explains the slot mechanism, node scaling, client routing, and the reasons behind the 16K slot choice.
This article explains how to use PHP's mysqli_query function to connect to a MySQL database, execute SELECT statements, process result sets with mysqli_fetch_assoc, and handle other query types such as INSERT, UPDATE, and DELETE, including full example code and best practices.
This guide explains how to download, install, and verify MySQL on Windows, macOS, and Linux, configure the server and user permissions, and demonstrates essential SQL commands for creating databases, tables, and manipulating data, providing a comprehensive introduction for beginners.
Redis evolved rapidly, with versions up to 5.x handling all core CRUD commands on a single worker thread, while Redis 6 introduced multi‑threaded network I/O to leverage multi‑core CPUs, yet still processes core business commands single‑threadedly for performance and simplicity, as explained with diagrams.
Redis 8.0-M03 adds an RDB channel replication feature that parallelizes RDB file transfer with write command streaming, reducing master node memory pressure and CPU load while improving full‑sync performance through a dedicated connection and configurable buffer limits.
The article explains why Redis needs asynchronous IO threading, describes the shortcomings of previous IO‑thread models, details the design of the new async IO thread architecture with event‑notified client queues and thread‑safety mechanisms, and presents performance test results showing up to double the QPS and significantly lower latency.
The article explains what constitutes a Redis large key, outlines its performance and stability risks, describes common scenarios and root causes, and provides practical detection commands, mitigation techniques such as splitting, compression, proper data modeling, and monitoring strategies to prevent future issues.
This article examines DeepSeek, a Chinese AGI‑focused AI model, explains prompt‑engineering techniques, and evaluates its performance across database architecture, development, and operations tasks through concrete Q&A examples, SQL plan analysis, and shell‑script generation, while also discussing its broader impact on professionals, vendors and enterprises.
Redis achieves exceptional speed by storing all data in memory, using a single‑threaded event‑driven architecture with epoll/kqueue, employing efficient I/O multiplexing, optimizing data structures such as strings, hashes and sorted sets, and providing flexible persistence and high‑availability options, all of which are detailed in this article.
This article compiles a wide range of Linux C/C++ interview questions covering language fundamentals, data structures, algorithms, operating systems, networking, databases, and general problem‑solving approaches to help candidates assess and improve their technical knowledge.
This article details Redis's expiration mechanisms, comparing lazy (passive) deletion with periodic (active) deletion, and outlines the auxiliary memory eviction policies, highlighting their principles, pros, cons, and ideal use cases.
This article demonstrates how to connect to a MySQL database using mysqli, execute SELECT queries, and retrieve results row by row with the mysqli_fetch_assoc function in PHP, providing complete code examples for connection, querying, result iteration, and proper resource cleanup.
Redis, a non‑relational database, implements transaction-like behavior using commands such as MULTI, EXEC, DISCARD, and WATCH, allowing queued execution, optimistic locking, and various rollback granularities, though its semantics differ from traditional relational database transactions.
This article explains the concept and syntax of SQL window functions, demonstrates basic and advanced use cases with step‑by‑step data preparation, queries using row_number() and lag, and provides complete scripts to solve common interview‑style ranking problems.
Redis Sentinel provides a robust high‑availability solution by monitoring master‑slave clusters, automatically detecting failures, electing leaders, and performing failover, while using quorum voting, Pub/Sub communication, and configuration provisioning to ensure seamless master promotion and client redirection without manual intervention.
This article introduces ten common Python database interaction patterns—from basic CRUD operations and table creation to advanced transaction handling, batch inserts, and stored procedures—culminating in a complete user‑registration system example that demonstrates how to combine these techniques effectively.
The article explains ACID properties, details how inadequate isolation levels cause dirty reads, non‑repeatable reads, and phantom reads, illustrates each with transaction scenarios and diagrams, and shows how MySQL’s lock types and isolation settings prevent these anomalies, noting the trade‑off between isolation and concurrency.
This guide explains step‑by‑step how to prepare the operating system, install required software, configure PHP and web servers, and test the setup on Windows, macOS, and Linux, providing practical tips and troubleshooting for a stable PHP development environment.
This article introduces Redis bitmap operations, explains key commands such as BITSET, BITGET, and BITCOUNT, and demonstrates with PHP code how to implement an efficient user sign‑in tracking and counting system using bitmaps for accurate statistics.
This article summarizes Professor Cai Peng's presentation on diagnosing online database performance anomalies, covering traditional rule‑based and statistical root‑cause SQL methods, novel learning‑based techniques such as adaptive time‑window selection and multi‑metric analysis, experimental results, and real‑world case studies.
This article compiles essential MySQL interview questions covering data types, char vs varchar, TRUNCATE vs DELETE, triggers, storage engines, lock mechanisms, transactions, stored procedures, index fundamentals, creation syntax, performance impact, and practical optimization techniques with example SQL code.
The article describes a production deadlock (ORA-000060) caused by unsorted, duplicate user_id rows in a file processed in parallel batch updates, shows MyBatis XML code, illustrates conflicting thread execution, and provides practical solutions such as sorting the input and deduplicating records.
This article explains how to leverage the NativePHP library within the Laravel framework to build high‑performance desktop applications by executing CLI commands, manipulating the file system, and performing database operations with native PHP code examples.
This article explains how to use PHP's mysqli_query function to connect to a MySQL database, execute SELECT queries, handle result sets, and perform other operations such as INSERT, UPDATE, and DELETE, including a complete example code snippet and best practices for error handling.
This article explains the fundamentals of SQL injection attacks, demonstrates step‑by‑step exploitation using the DVWA platform—including data extraction, login bypass, and injection point detection—and outlines practical prevention techniques such as input validation, regex filtering, and prepared statements.
This article provides a comprehensive overview of MongoDB's configuration file, detailing system log options, process management, network settings, security parameters, storage engine configurations, slow query profiling, replication, sharding, and mongos-specific settings, with explanations of each option and recommended defaults.
This article presents a comprehensive overview of NL2SQL, covering its definition, motivations, application scenarios, key technical components, evaluation metrics, historical development stages, and detailed descriptions of three laboratory projects—GAR, MetaSQL, and PURPLE—along with future research directions and a Q&A session.
This article experimentally compares the performance of various MySQL COUNT queries on an InnoDB table with one million rows, explains the underlying execution plans using EXPLAIN, analyzes primary‑key versus secondary‑index behavior, and contrasts InnoDB’s fast count implementation.
This article explains the three major Redis cache issues—cache avalanche, cache breakdown, and cache penetration—how they can overload databases, and provides practical solutions such as high‑availability deployment, appropriate key expiration, local caches, mutex locks, empty‑object caching, request validation, and Bloom filters.
This article explains why MySQL alone struggles with large‑scale, complex queries, introduces Elasticsearch as a high‑performance search engine, and compares several synchronization approaches—including synchronous and asynchronous dual‑write, Logstash, binlog real‑time sync, Canal, and Alibaba Cloud DTS—highlighting their pros, cons, and suitable scenarios.
This article provides a comprehensive, step‑by‑step guide to essential MySQL commands—including connection, process inspection, variable queries, lock information, transaction status, engine details, character set checks, import/export, index management, table creation, stored procedures, and view creation—complete with example code snippets for each operation.
This guide provides a comprehensive overview of Redis data structures—including strings, hashes, lists, sets, and sorted sets—along with essential commands for creating, reading, updating, and deleting keys, managing expirations, and performing set operations, enabling developers to effectively leverage Redis as a high‑performance NoSQL database.
This comprehensive guide walks you through MongoDB replica set fundamentals, member roles, architecture, and configuration commands, then dives into sharding concepts, cluster components, chunk management, shard key selection, deployment steps, balancing operations, and practical troubleshooting tips, all illustrated with clear code examples and diagrams.
This article presents a complete MongoDB migration solution, detailing the migration rhythm, code refactoring using a decorator pattern, data source replacement with JImKV, MySQL and ES, bulk and incremental data transfer strategies, and deployment safeguards such as monitoring, gray release, and rollback to ensure a seamless cut‑over without service disruption.
This article explores common overselling problems in high‑concurrency flash‑sale scenarios and presents seven practical solutions—including lock timing adjustments, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—each illustrated with SpringBoot code and performance test results.
MySQL 9.2.0 introduces the CREATE_SPATIAL_REFERENCE_SYSTEM privilege, JavaScript library support, enhanced SQL stored routine APIs, ENUM and SET handling, EXPLAIN FORMAT=JSON version 2, while deprecating several version‑token functions and privileges and removing keyword restrictions, providing a comprehensive overview of additions, deprecations, and removals.
The article examines inventory pre‑reservation in e‑commerce, detailing performance challenges under high concurrency, and evaluates solutions such as asynchronous rate limiting, horizontal stock splitting, Redis caching, database transaction handling, deadlock avoidance, and data consistency mechanisms, highlighting a 24‑fold throughput increase.
This article analyzes a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, and JMeter, demonstrates seven implementations—from service‑level locks to AOP, pessimistic/optimistic locks, and queue‑based designs—examines their trade‑offs with concrete code, test results, and practical recommendations.
This guide outlines the ten fundamental Linux operations tools and skills—ranging from basic system knowledge and networking services to shell scripting, text processing, databases, firewalls, monitoring, clustering, and backup—that every aspiring sysadmin should learn and practice thoroughly.
This article explains why JDBC access to OceanBase (Oracle mode) LOB columns can trigger an ORA-06502 "no data found" error, analyzes the driver’s readFromServer implementation, and shows how disabling the useLobLocatorV2 option eliminates the exception.
This technical guide breaks down Alibaba's Druid JDBC connection pool, detailing its initialization process, how connections are fetched and returned, the internal threads and condition‑signal coordination, execution handling, recommended configurations, and monitoring integration, all illustrated with code snippets and diagrams.
Redis offers three persistence options—Append‑Only File (AOF) which logs every write, RDB snapshots that capture point‑in‑time data, and a hybrid mode combining both—each configurable with trade‑offs in durability, recovery speed, file size, and performance to suit different application needs.
When a client sends an SQL statement over TCP, the parser checks syntax and semantics and builds a query tree, the optimizer evaluates possible execution plans using statistics to estimate costs and selects the most efficient one, and the executor runs the plan, using the buffer manager for reads or the transaction manager for updates while the lock manager enforces ACID properties.
This article presents an e‑commerce interview case that defines three tables (orders, order_items, products), loads sample data, and walks through a step‑by‑step SQL solution using CTEs, aggregation, window functions and HAVING to calculate each customer's total spend, most expensive order, and favorite product category, filtering and sorting the results.
This article explains the meaning of the Extra column in MySQL EXPLAIN results, covering common values such as Using index, Backward index scan, Select tables optimized away, and Zero limit, and shows how to interpret and optimize each case with concrete examples.
This course introduces MySQL 8's latest features—including performance optimizations, security enhancements, and new data types—while deeply exploring its network communication mechanisms, advanced optimization techniques, and hands‑on projects to improve database performance and security.
This article presents a comprehensive collection of written‑test and interview questions covering Java basics, Spring MVC annotations, JVM memory, garbage collection, database design, transaction management, distributed systems, version control, and development workflow, aimed at helping candidates prepare for small‑company technical interviews.
This article walks you through MySQL's default ports, provides a concise introduction, details how to download the Community Server, explains extraction, environment variable setup, configuration file creation, service registration, and shows essential commands for initializing, starting, stopping, and managing MySQL users on Windows.
This article explains the locality principle—time and space locality—and shows how applying these concepts to caching and data access in distributed systems can dramatically reduce database query volume, improve latency, and achieve up to 84% performance gains while managing memory and GC overhead.
This guide compiles the most common MySQL interview questions asked by leading Chinese tech firms, covering fundamentals, data types, storage engines, indexes, transactions, locks, views, stored procedures, triggers, and optimization, with clear explanations, diagrams, and a free downloadable resource.
This guide outlines how to add a logistics tracking feature to a PHP e‑commerce site by collecting tracking data, integrating a courier API, parsing and storing the information, displaying it to users, and regularly updating the status to enhance trust and user satisfaction.
This article walks through a real MySQL deadlock case, explaining the background, reproducing the issue, analyzing lock information from InnoDB status, and presenting practical steps to identify root causes and fix the deadlock safely.
This article provides a comprehensive technical walkthrough of the Druid database connection pool, covering its architecture, initialization flow, connection acquisition and release mechanisms, execution and exception handling, as well as recommended configurations and monitoring practices for optimal performance.
The article reports that MySQL versions 8.4.3 and 9.1.0 deliver notable performance gains across a variety of workloads, explains the benchmark methodology, presents quantitative QPS improvements, and details four key internal changes—including a binlog data‑structure switch, JOIN optimizations, and enhanced index range scans—that together raise write and read throughput by several percent.
This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, Mybatis‑Plus and JMeter, analyzes the overselling problem caused by premature lock release, and presents seven solutions—including lock‑first strategies, AOP, pessimistic and optimistic locks, and queue‑based approaches—along with code samples and test results.
This article provides a comprehensive overview of LLM-based Text-to-SQL technology, covering its background, evolution, challenges, various LLM-driven methods, benchmark datasets, evaluation metrics, and future research directions to guide researchers and practitioners in advancing natural language interfaces for databases.
This article investigates a Redis Sentinel failover anomaly in version 7.4.0 where the sentinel repeatedly elects a failed master, explains the underlying s_down/o_down states, examines network, configuration, and ACL settings, and resolves the issue by adjusting Pub/Sub permissions to allow proper failover.
Redis Sets are unordered collections of unique strings backed by hash tables that provide O(1) add, delete, and lookup operations, automatically switch to a compact integer array (intset) for small integer-only sets, and are ideal for deduplicated data and fast set operations such as intersection, union, and difference, exemplified by computing common friends in social applications.
A ClickHouse cluster showed wildly varying row counts when querying sharded tables, while local tables behaved correctly; the article analyses the root cause in the cluster and table configuration, explains why the inconsistency occurs, and provides a step‑by‑step fix by switching to replicated tables.
This article explores practical techniques for boosting system performance through IT architecture optimization, covering caching strategies, database query and connection‑pool tuning, load‑balancing, asynchronous messaging, code‑level refinements, memory pooling, network tricks, and real‑world case studies.
This article explains why Redis, an in‑memory database, needs persistence, compares the four official persistence options (RDB, AOF, RDB+AOF, and no persistence), details their configurations, performance trade‑offs, and introduces the hybrid RDB+AOF approach for balanced durability and speed.
This guide explains why a production Redis cluster may show intermittent timeouts and READONLY errors, analyzes root causes such as network jitter, resource saturation, and costly commands, and provides step‑by‑step troubleshooting and configuration fixes to restore stability and performance.
This article explains how to use PHP's mysqli_query function to perform MySQL operations such as SELECT, INSERT, UPDATE, and DELETE, providing a step‑by‑step example that creates a connection, runs a SELECT query, processes results, and closes the connection.
This article explains what PHP built-in objects are, categorizes them by request handling, file operations, database access, and exception handling, and demonstrates their usage with code examples to write more elegant, secure, and efficient backend code.
This article examines how MySQL pagination performance degrades as table size grows, presents real‑world timing tests on a million‑row customer table, and offers three practical solutions—including selecting only primary keys, ID‑range filtering, and leveraging ElasticSearch—to dramatically improve query speed.
This article demonstrates how to store SQL queries in .ini files and use Python's mysql-connector-python library together with configparser and logging to perform MySQL CRUD operations, providing full code examples and explanations for configuration, connection handling, query execution, and log management.
Limbo, Turso’s Rust‑based rewrite of SQLite, aims for full compatibility while adding memory safety, asynchronous I/O via io_uring, deterministic simulation testing, and WebAssembly compilation, delivering comparable or superior performance on large datasets and showcasing the challenges and benefits of re‑engineering a mature database engine.
This article explains Spring's transaction management, covering ACID principles, transaction propagation types, isolation levels, timeout settings, read‑only flags, rollback behavior, and the effect of asynchronous execution, supplemented with practical code examples and common pitfalls.
This article explains the segment‑mode ID generation strategy, analyzes its pros and cons, describes suitable application scenarios, and provides a complete Java implementation with database schema, supporting classes, and a multithreaded test case for high‑concurrency environments.
This article explains the internal process MySQL 8.0.32 InnoDB uses to allocate, create, and manage Undo segments—including cached segment retrieval, new segment creation, insertion into rollback segment lists, conflict avoidance through mutexes, and a concise step‑by‑step summary of the entire workflow.
This article recounts a midnight CPU alert incident and walks through systematic backend troubleshooting—from initial system checks and JVM profiling to algorithm refactoring, database indexing, Docker‑based isolation, and proactive monitoring—demonstrating how to restore service performance and prevent future outages.
DBOS, a Database‑Oriented Operating System proposed by Matei Zaharia and Michael Stonebrake, builds the OS atop a distributed, ACID‑compliant database, storing all system and application state in tables, which simplifies scaling, ensures strong consistency, improves debugging, and reduces attack surface for cloud‑native workloads.
This article explains how to accurately calculate the real data size in OceanBase by using OCP cluster overview, system views, and SQL queries for server‑level, tenant‑level, and table‑level statistics, covering differences between V3 and V4 versions and the use of obdiag.
Redis Labs announces the return of its founder Antirez, who shares his reasons for rejoining, discusses the recent licensing shift, reflects on his past projects, and outlines future plans for AI integration, vector indexing, and community engagement within the Redis ecosystem.
The article examines the DBOS concept—a database‑oriented operating system that places a distributed, transactional database at the core of OS services, tracing its roots from early database pioneers to modern cloud workloads and highlighting its potential advantages over traditional Linux‑Kubernetes stacks.
Because MyBatis reads a primitive boolean field directly when no getter exists, the default false value is bound as 0, causing an unexpected zero in the MySQL tinyint column; changing the field to the Boolean wrapper (initialized to true) or fixing the update logic resolves the issue.
This article explains how multi‑table joins in MySQL can become performance bottlenecks and walks through the four join algorithms—Simple Nested‑Loop, Block Nested‑Loop, Hash, and Index Nested‑Loop—showing their execution plans, code examples, and step‑by‑step optimizations using indexes and join buffers to dramatically improve query speed.
This article examines the pitfalls of using Redis key‑expiration notifications for delayed business actions, presents a Docker‑based benchmark, provides Spring‑Boot code for scheduling and listening to expirations, and analyzes how notification latency grows as the number of keys increases.
The article explains that while Docker is convenient for learning environments, deploying MySQL in containers poses serious data‑safety, performance, and resource‑isolation problems, and it outlines scenarios where containerizing MySQL may still be viable before shifting to promotional content about AI communities.
This article walks through 13 practical MySQL techniques—including group_concat, char_length, locate, replace, now, various INSERT variations, SELECT FOR UPDATE, on duplicate key update, SHOW CREATE TABLE, CREATE TABLE … SELECT, EXPLAIN, SHOW PROCESSLIST, and mysqldump—providing clear examples, SQL snippets, and screenshots to help developers write more efficient and reliable queries.
The article explains how JDBC’s setQueryTimeout and Spring’s transaction timeout work, reveals why SQL statements can become indefinitely blocked in the socket read phase, and provides practical configuration steps—including driver URL parameters—to prevent such blocking in MySQL, SQL Server, and Oracle environments.
This article walks through adapting the open‑source fake2db tool to work with Huawei's GaussDB, covering environment setup, driver installation, code changes, testing, and exposing the generated data via a Django‑based RESTful API.
This article explains why MySQL adopts B+ trees for its indexes, examining the impact of disk I/O latency, comparing B‑tree variants, and showing how B+ trees reduce I/O operations while supporting efficient range queries and balanced performance for large datasets.
This article explains how to extend an existing MySQL master‑slave replication filter to include additional databases by using a low‑cost backup‑restore workflow, detailing two solution options, the chosen approach, and step‑by‑step commands for stopping replication, backing up, setting GTID points, restoring, and updating filter rules.
This article compiles 40 core MySQL interview questions covering ACID properties, lock types, views, stored procedures, JOINs, storage engines, query optimization, buffer pools, write buffers, transaction mechanisms, MVCC, isolation levels, gap locks, metadata locks, thread model, row formats, and more, providing concise answers for each.
This guide explains ThinkPHP 4.0+ entity models, covering their layered architecture, installation, entity and model definitions, automatic relation queries, new type casting, accessors, configuration options, virtual and view models, with full code examples and practical tips for backend developers.
This guide compiles the 20 most common Linux and Kubernetes troubleshooting commands, illustrating typical outputs and step‑by‑step diagnostic reasoning for high CPU load, disk pressure, network failures, pod crashes, node issues, service outages, database errors, and application performance problems.
This article explores why leading enterprises and developers favor PostgreSQL, detailing its widespread adoption by major firms, its robust feature set, historical evolution, and how its extensibility and open‑source nature make it a compelling alternative to traditional enterprise databases.
This article explains how to expose a lightweight, dependency‑free client API for a Rust‑based database by defining a simple TCP‑based JSON serialization protocol, detailing non‑functional and functional requirements, the Message and Command structures, and providing a concrete Ping command implementation in Rust.
The author compares IDEA's built‑in database tool with Navicat for running massive SQL scripts, showing that IDEA consistently uses less CPU, avoids freezes, and achieves higher execution speed—even on files up to 1.83 GB—making it the preferred choice for large‑scale database migrations.
This guide explains how to create a flexible, maintainable settings system in Laravel by storing configuration key‑value pairs in a database, generating migrations, models, seeders, service‑provider boot logic, and an admin Blade form for editing settings.
