This article explains which components—user processes, I/O wait, and system interrupts—consume most CPU in MySQL, describes the performance impact of high CPU, and provides concrete strategies such as reducing I/O, simplifying calculations, optimizing indexes, and judiciously scaling hardware to lower CPU usage.
This article investigates the high CPU usage and latency observed after expanding a large Redis cluster, analyzes the root cause in the CLUSTER SLOTS implementation and client MOVED handling, proposes an optimized slot‑traversal algorithm, and demonstrates significant performance improvements through benchmarking and profiling.
When a MySQL table is sharded into multiple databases or tables, the usual LIMIT offset, pagesize pagination breaks, and this article examines why simple merge fails, then presents three practical approaches—global limit, secondary queries, and jump‑page restriction—highlighting their trade‑offs and limitations.
This article examines why a MySQL composite index on (first_name, last_name) initially fails to be used for ordering, demonstrates how adding a range predicate reduces the scanned row count, and explains the threshold at which MySQL switches from filesort to index‑based retrieval.
This article explains the fundamentals of MVCC, transaction isolation levels, and related concepts such as ACID properties, dirty reads, non‑repeatable reads, phantom reads, hidden columns, undo logs, version chains, read views, and demonstrates how InnoDB implements these mechanisms with practical SQL examples and diagrams.
This article presents a practical, seven‑step methodology for efficiently reading Redis source code, covering project mapping, prerequisite knowledge, starting from basic modules, identifying the core execution path, balancing overall structure with detailed logic, handling auxiliary features, and performing targeted gap‑filling to master the codebase.
This article explains MySQL InnoDB's locking mechanisms—including record locks, gap locks, and next‑key locks—detailing how they work, their interaction with isolation levels such as Repeatable Read, and the principles, optimizations, and examples that illustrate their impact on concurrency and phantom reads.
This article explains how MySQL handles concurrent transactions using MVCC, lock mechanisms, and various isolation levels, detailing dirty writes, dirty reads, non‑repeatable reads, phantom reads, and the internal structures such as ReadView that enable reliable data consistency.
This tutorial introduces PostgreSQL, compares its advantages over MySQL, shows how to download and install it, and provides a complete Spring Boot integration guide with detailed configuration, entity mapping, repository creation, and unit‑test driven CRUD operations.
This article introduces MySQL 8.0's enhanced JSON capabilities, covering key constraints, storage functions, GeoJSON support, indexing, in‑place updates, essential JSON utilities, path expressions, extraction, modification techniques, and the powerful JSON_TABLE feature with clear code examples.
This article explains the core concepts of B‑trees and B+‑trees, compares them with red‑black trees, details their node definitions and insertion algorithms, and shows why B+‑trees are preferred for database and file indexing due to lower I/O cost and stable search paths.
This article explains how MySQL 8.0 introduces strict JSON schema validation, demonstrates the json_schema_valid and json_schema_validation_report functions with array and object examples, and shows how to enforce schema checks in tables using CHECK constraints.
This tutorial demonstrates how to leverage Spring AOP in a Spring Boot project to automatically fill common audit columns such as creator, creation time, updater, and update time for database tables, eliminating repetitive manual SQL handling and centralizing logging logic.
This article explains microservice fundamentals, their advantages, technical characteristics, and provides a comprehensive guide to data design in microservice architectures, covering decoupling, lightweight APIs, continuous delivery, database per service versus shared databases, polyglot persistence, scaling strategies, and why MongoDB is a suitable choice.
The article explains why idempotency is essential for reliable services, describes how unique identifiers such as UUIDs and Snowflake-generated IDs can guarantee idempotent operations, and outlines practical storage and query techniques using databases or Redis to prevent duplicate orders, inventory deductions, and payments.
A Monday morning surge in user traffic exposed a Redis performance crisis, where CPU spiked to 100% due to massive keys* commands, and the investigation using Grafana, Redis info, commandstats, and slowlog revealed the root cause and a temporary mitigation strategy.
This article explains MySQL index fundamentals, B+‑tree implementation, the left‑most prefix rule, back‑to‑table issues, and provides three practical optimization cases with code examples to help developers design efficient composite indexes and avoid performance pitfalls.
This article explains how to implement a student QR‑code seat‑selection feature using PHP, detailing database schema design, URL parsing, seat‑allocation logic, attendance tracking, and daily cleanup tasks, enabling teachers to monitor seating without login while automatically recording student attendance.
This article demonstrates how MyBatis dynamic SQL simplifies conditional query building by explaining the usage of if, choose, foreach, trim, and bind tags, providing Maven project setup, table creation scripts, mapper interfaces, XML snippets, and unit test examples for SELECT, UPDATE, INSERT, and batch operations.
This article presents a concise guide to the most frequently used MySQL commands, covering how to list databases and tables, create and drop databases and tables, and perform essential CRUD operations such as inserting, querying, updating, and deleting records.
This article summarizes the most useful MySQL 8.0 JSON features—including storage limits, indexing, in‑place updates, path expressions, merging, and table functions—providing clear code examples and guidance for developers who need to work with JSON data in MySQL.
This article examines the fundamental characteristics of Redis, explains why network latency often dominates performance, and presents practical optimization strategies such as using Unix IPC, multi-key commands, transactions, scripts, pipelining, avoiding slow commands, tuning persistence, adjusting OS settings, and adopting distributed architectures to achieve higher throughput and lower latency.
This article explains MySQL index fundamentals, advantages, types, and structures, demonstrates how to interpret EXPLAIN output, and presents six real‑world slow‑query cases with step‑by‑step optimizations, including index creation guidelines, invalidation pitfalls, ORDER BY tuning, and join improvements.
This article presents a detailed interview-style walkthrough of Redis fundamentals, covering its thread model, persistence mechanisms (AOF, RDB, hybrid), command behaviors, high‑availability options, and the hash‑slot based clustering algorithm, illustrated with code snippets and diagrams.
This tutorial walks through ten advanced Django ORM QuerySet methods—exclude, values, values_list, select_related, order_by, exists, count, first/last, in_bulk, and explain—showing how each works with practical code examples using Student and School models.
This article provides a comprehensive collection of typical MySQL interview questions covering storage engines, lock types, gap locks, deadlock avoidance, isolation levels, index types, covering indexes, left‑most prefix rule, replication, distributed transactions, optimization techniques, sharding challenges and solutions, and global unique ID generation.
This article walks through a practical performance test for continuously adding key‑value pairs to Redis using the FunTester framework, detailing the test design, Java and Groovy implementations, execution logs, result metrics, and key takeaways for future Redis benchmarking.
This article explains the causes, impacts, and various techniques of SQL injection attacks in PHP applications, demonstrates vulnerable code examples, and provides practical mitigation measures such as input validation, error handling, character encoding considerations, and secure coding practices.
This weekly roundup, presented by the community reporter Yongzheng, compiles the latest MySQL issue links, a Python automation video course, DBLE and DTLE open‑source progress, new feature developments, bug fixes, community Q&A, and plans for the upcoming week.
This article explains why using a large OFFSET with MySQL LIMIT can cause severe performance degradation, demonstrates the problem with a real‑world 9.5 million‑row table, and shows how rewriting the query with a sub‑query that selects only primary keys can cut execution time from seconds to milliseconds.
This article demonstrates how to use Spring Boot's AOP features to automatically populate common audit columns such as creator, creation time, updater, and update time during DAO insert and update operations, eliminating repetitive manual SQL handling.
The article demonstrates how to use MySQL error logs and gdb to trace a crash‑related bug, identify the affected function in the source code, compare version histories on GitHub, and confirm that the issue was fixed in MySQL 8.0.20.
This guide explains how multi‑index support in Table Store enables SQL push‑down of filters, relational operators, aggregation functions, and LIMIT clauses, dramatically reducing query latency on non‑primary‑key columns and providing practical examples with a bike‑rental dataset.
This article examines the consistency challenges when using Redis as a cache for database data, compares three update strategies, and presents practical solutions such as delayed double‑delete, retry mechanisms, and handling cache penetration, avalanche, and thread‑safety issues in Java.
This article explains why MySQL queries become slow, how proper indexing, MDL locks, sharding, read‑write separation, and large‑table strategies can improve performance, and also introduces Elasticsearch and HBase as complementary technologies for search and high‑write workloads.
This article explains how MySQL treats backslashes as escape characters in INSERT and SELECT queries, demonstrates the effect of different numbers of backslashes through practical tests, and clarifies the double‑escaping required when using LIKE patterns.
This article compiles 20 classic Redis interview questions covering its definition, data structures, performance mechanisms, caching challenges, high‑availability setups, persistence options, distributed locking techniques, and best‑practice solutions, providing developers with comprehensive insights into Redis architecture and practical usage.
This comprehensive guide covers essential SQL concepts, clause usage, aggregate functions, view creation, sequences, indexes, and a collection of classic interview questions with detailed solutions, helping readers deepen their database knowledge and ace SQL interviews.
This article explains what Redis Sentinel is, its architecture, how to configure sentinel.conf, monitor master and slaves, handle slave and master failures, and set up multiple sentinel instances for robust high‑availability in a Redis master‑slave environment.
This guide walks through selecting a clustering strategy, installing Percona XtraDB Cluster (PXC) with Docker, configuring a five‑node cluster, adding HAProxy for load balancing, testing access, and handling node failures to achieve strong consistency and high availability for critical data.
This article provides a thorough introduction to MyBatis, including a complete beginner example with database schema, Maven configuration, XML and Java mapper files, and a demo program, followed by an in‑depth explanation of MyBatis’s lifecycle, core components such as SqlSession, Executor, StatementHandler, ParameterHandler, ResultSetHandler, and their interactions.
This article provides a comprehensive tutorial on setting up a one‑master‑one‑slave Redis replication environment, configuring read‑write separation, verifying data synchronization, testing read‑only behavior, and performing performance benchmarking with redis‑benchmark, complete with command examples and result analysis.
This article reviews the evolution of big data technologies in the last five years, covering streaming and batch processing frameworks, column‑store NoSQL databases, programming language trends, the cloud‑native multi‑model database Lindorm, and practical Flink/Blink usage with code examples.
The article explains why running MySQL in Docker containers can lead to data loss, performance degradation, and inadequate resource isolation, while also outlining specific scenarios where containerizing MySQL may still be appropriate.
This article introduces the six fundamental parts of Structured Query Language (SQL)—DQL, DML, TPL, DCL, DDL, and CCL—while promoting a comprehensive Alibaba Cloud developer course that covers each component with detailed lessons and practical examples.
This article presents a detailed performance benchmark comparing MariaDB 10.4.12 and MySQL 8.0.19 on an i7 Windows 10 system, covering single and batch inserts, indexed and non-indexed queries, and analyzes speed and memory usage differences between the two databases.
Redis, the high‑performance open‑source key‑value store, uses a master‑slave replication mechanism that ensures data redundancy, read/write separation, fault recovery, and high‑availability; this article explains its handshake process, synchronization phases, replication states, and key source‑code functions in detail.
This article provides a comprehensive technical overview of financial‑grade database disaster recovery, covering backup and recovery methods, MySQL replication options, automatic failover architectures, distributed transaction protection, and application‑level stress mitigation techniques.
This article explains why MySQL uses locks, describes table‑level, row‑level, and page‑level locking, outlines lock types such as shared, exclusive, and intention locks, and provides practical usage examples and common troubleshooting tips for InnoDB and other storage engines.
This article documents the author's first experience debugging ClickHouse source code with GDB, explains the memory‑limit issue encountered when importing large MySQL tables, shows how to inspect stack frames, adjust the max_block_size setting, and verify the fix with a test insert.
This article presents a complete MySQL interview guide, including a script to create and populate tables for students, teachers, courses, scores, and grades, followed by 33 common interview questions with detailed SQL solutions covering selection, aggregation, joins, subqueries, and ordering.
This article explains Redis Sentinel's role in providing high availability by detailing how Sentinels discover each other, detect master failures, elect a new master, and communicate state using the gossip protocol, offering a clear conceptual overview for database practitioners.
This article explains Redis's fundamental and advanced data structures, outlines its single‑threaded in‑memory architecture, and provides practical guidance on scanning large keyspaces, spreading expiration times, and choosing between AOF and RDB persistence methods.
This article explains Redis's virtual memory (VM) feature, how it swaps cold data to disk while keeping keys in memory, details configuration parameters, describes the two threading models for data swap-in/out, and highlights why Redis's custom VM implementation boosts performance.
This article reviews Redis's latest features and compares various deployment architectures—including single‑replica, dual‑replica, cluster, and read‑write‑separation modes—detailing their reliability, performance characteristics, suitable use cases, and provides a Java Jedis example for configuring a direct‑connect cluster.
An in‑depth analysis of MySQL Group Replication (MGR) transaction certification failures, covering error symptoms, root‑cause investigation, replication‑group transaction set mismatches, and step‑by‑step recovery procedures with code examples and best‑practice recommendations to keep MGR clusters clean.
The article examines a real‑world scenario where a developer tried to reuse existing stored procedures to merely check the presence of Job, Certification, and Disclosure records, discusses the pitfalls of such an approach, and explains why storing this logic in T‑SQL is often fragile and hard to maintain.
This article explains why Redis, despite being single‑threaded, can encounter thread‑safety problems, discusses efficiency bottlenecks caused by network latency, and shows how embedded Lua scripts can create custom atomic commands, with practical examples and important considerations.
Redis, traditionally seen as a high‑performance cache, also offers rich data structures, persistence options, and clustering modes that enable it to function as a primary database for many internet services, supporting use cases such as user profiles, counters, leaderboards, friend relationships, distributed locks, rate limiting, and more.
The article explains Redis 6.0's new features—especially the multithreaded network I/O model—why earlier versions were single‑threaded, how the IO threads cooperate with the main thread, configuration steps, thread‑count recommendations, and the model's limitations and performance implications.
When using MySQL pagination with LIMIT together with ORDER BY, the second page can unexpectedly contain rows from the first page because MySQL 5.6's priority‑queue optimization performs an unstable heap sort, causing nondeterministic ordering for equal values and leading to duplicate results.
This article explains why MySQL queries become slow, how proper indexing and index‑pushdown can improve performance, discusses common index‑failure causes, and then introduces Elasticsearch and HBase as complementary search and storage solutions for large‑scale data, including practical usage tips and architectural considerations.
This article outlines the new features of Redis 6.0 and 5.0, compares various deployment architectures such as master‑replica, single‑replica, cluster and read‑write split, presents typical usage scenarios, and provides a Java Jedis code sample for connecting to a Redis cluster.
The article describes how a bank built a Kubernetes‑based, containerized MySQL service platform (CDD) to improve database high availability, resource utilization, automated operations, and agile delivery by addressing network, storage, scheduling, and management challenges through custom networking, hybrid storage, scheduler extensions, and multi‑AZ deployment.
MySQL 8.0 introduces several relational‑database enhancements, including invisible indexes for performance tuning, persistent configuration via SET PERSIST, default utf8mb4 character set, support for Common Table Expressions, and window functions, each illustrated with practical SQL examples.
This article explains why Redis can encounter thread‑safety‑like problems, how network latency limits its performance, and how embedding Lua scripts lets you create atomic, server‑side commands that overcome these issues while providing practical code examples.
This article examines the consistency challenges of using Redis as a cache, compares three update strategies—updating the database before the cache, deleting the cache before updating the database, and updating the database then deleting the cache—analyzes their pitfalls, and presents practical solutions such as delayed double‑delete, asynchronous retries, and binlog‑driven cache invalidation.
This article explains the fundamentals of local transactions and ACID properties, introduces CAP and BASE theories, discusses compensation jobs and transaction messages, and reviews distributed transaction models such as two‑phase commit, three‑phase commit, XA, TCC, Saga, and the Seata framework.
This article explains why MySQL queries become slow—covering index misuse, MDL locks, flush waits, row locks, and large‑table bottlenecks—then introduces ElasticSearch’s inverted‑index architecture and HBase’s column‑family storage, offering practical tips for performance tuning and hybrid solutions.
This article explains why Redis needs persistence, describes the two main persistence mechanisms—RDB snapshots and AOF command logging—their configuration, internal structures, operational principles, and trade‑offs, and provides practical code examples for implementing and tuning them.
This article examines financial sector database disaster recovery, defining disaster recovery and backup, analyzing current practices and requirements, reviewing market trends, and detailing various distributed database disaster‑recovery architectures such as single‑center, intra‑city active‑active, and multi‑site three‑center solutions.
This article presents a comprehensive overview of Alibaba's intelligent marketing advertising platform, covering business fundamentals, microservice migration, service governance, database design, real‑time data transmission, billing, reporting, and performance optimizations for high‑throughput, low‑latency ad delivery.
A programmer needed to create a billion‑row SQLite test database within a minute, found a naïve Python script unbearably slow, applied batch inserts and SQLite PRAGMA tweaks, then compared CPython, PyPy, and Rust implementations, ultimately achieving sub‑minute runtimes with Rust and highlighting best‑practice optimizations.
This article offers a thorough overview of relational database fundamentals and SQL syntax, detailing core concepts, clause structures, DDL/DML/TCL/DCL commands, functions, transaction handling, user privileges, stored procedures, cursors, and triggers with practical code examples.
Kudu is an open‑source columnar storage engine from Cloudera that combines high‑throughput batch processing with low‑latency random reads, offering features such as C++/Java APIs, Raft‑based replication, flexible consistency, partitioning, and integration with Hadoop, Spark, Impala, and other ecosystem components.
This article provides a step‑by‑step Bash script for installing, configuring, and starting MySQL 8.0 on a Linux system, including user creation, directory setup, permission handling, initialization checks, and service management, and ensures proper environment variables.
This comprehensive guide covers everything from MongoDB's core concepts, data model, and architecture to practical commands for creating databases, collections, indexes, sharding, replication, aggregation, and troubleshooting, providing clear answers to over fifty frequently asked questions.
This article provides a comprehensive overview of MongoDB, covering its definition, document‑oriented storage, key features, differences from relational databases, sharding and replication mechanisms, common commands, data types, indexing, aggregation, and practical usage scenarios for modern applications.
The article presents a detailed interview‑style walkthrough of MySQL InnoDB locking mechanisms, covering table‑ versus row‑level locks, shared and exclusive locks, intention locks, gap and next‑key locks, auto‑increment locks, predicate locks, and related SQL statements, illustrated with tables and code examples.
This guide explains MySQL binary log fundamentals, the replication architecture, step‑by‑step configuration of master‑slave instances, essential commands, and troubleshooting tips for common replication problems such as lag, errors, and security settings.
This article explains how Redis implements the “nearby people” feature using its Geo module, detailing the GEOADD and GEORADIUS commands, their underlying algorithms, source‑code flow, and the resulting time‑complexity for adding and querying location data.
This article experimentally determines the maximum number of characters a MySQL 5.7 VARCHAR column can hold under different character sets, explains the underlying row‑size and index‑key restrictions, and provides concrete CREATE TABLE examples for latin1, utf8, and utf8mb4.
This article introduces MySQL 8.0's resource group feature, detailing its concepts, configuration commands, query hint usage, and the underlying implementation including new parser classes, platform APIs, runtime components, performance schema integration, and persistence mechanisms, with code examples throughout.
This guide walks you through installing pymysql, creating a MySQL database and table, connecting Python to MySQL, and performing full CRUD operations—including bulk inserts, updates, deletions, and queries—complete with code examples and screenshots.
This guide introduces four powerful MySQL performance‑tuning utilities—MySQLTuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—detailing their installation, command‑line usage, and how to interpret the generated reports to optimize database configuration and query efficiency.
This article explains several MySQL techniques—INSERT IGNORE, ON DUPLICATE KEY UPDATE, and REPLACE INTO—to efficiently insert large volumes of data while preventing duplicate primary‑key or unique‑key rows, and provides practical code examples for single and batch operations.
Apache Cassandra 4.0 has been officially released after a long development cycle, offering higher speed, better scalability, improved consistency, stronger security, reduced latency, and more efficient compression, while supporting enterprise compliance and a new annual release cadence for future stability.
The article explains Redis's two expiration key removal mechanisms—lazy deletion, which removes keys only when accessed, and periodic deletion, which randomly scans and deletes expired keys at regular intervals—detailing their concepts, pros, cons, and underlying source‑code implementations.
This article introduces the 'DBA攻坚指南' book, detailing its Oracle and MySQL performance‑tuning content, author credentials, key chapters, SQL health‑check scripts, usage examples, and the accompanying giveaway event organized by the 爱可生开源社区.
The article explains how IO and CPU bottlenecks increase active database connections, then details horizontal and vertical sharding techniques, practical tools, step‑by‑step implementation, and common pitfalls to help engineers relieve pressure on database resources.
This article explains what Redis Sentinel is, its architecture, how to configure it in a master‑slave environment, and demonstrates handling of slave and master failures as well as setting up multiple Sentinel instances for high availability.
After upgrading MySQL Connector/J from 8.0.18 to 8.0.20 on IBM JDK 1.8, SSL handshake failures occur due to mismatched cipher suite naming, and the article details analysis of MySQL and IBM JSSE2 TLS settings, packet captures, and multiple remediation strategies including JVM parameters and JDK upgrades.
This guide demonstrates how to switch a MySQL 5.7.32 deployment between Group Replication (MGR) and semi‑synchronous replication, covering environment checks, node configuration, plugin installation, replication setup, validation, and the limitations encountered when combining the two modes.
This article explains how MySQL index usage affects query performance, demonstrates that hitting an index does not guarantee speed, explores slow‑query logging parameters, shows practical experiments with EXPLAIN, and presents optimization techniques such as composite indexes, index condition push‑down, and virtual columns to reduce row scans.
This comprehensive guide covers SQL fundamentals—including database terminology, syntax structure, DDL/DML/TCL/DCL commands, CRUD operations, subqueries, joins, unions, functions, ordering, grouping, indexes, constraints, transactions, permissions, stored procedures, cursors, and triggers—providing clear examples and best practices for relational database development.
This guide explains how to install the MySQL driver for Python, establish a connection to a MySQL database using MySQLdb, execute queries, and optionally use ORM libraries such as SQLAlchemy or Peewee for higher‑level database interactions.
This article explains why message middleware guarantees at‑least‑once delivery, the challenges of duplicate consumption, and presents both simple and advanced deduplication strategies—including transactional and non‑transactional approaches using relational databases or Redis—to achieve effectively exactly‑once semantics in RocketMQ.
This article reviews Redis 6.0 and 5.0 new features, compares cluster, master‑replica (single and double replica), and read‑write‑separation architectures, explains their reliability and use‑case scenarios, and provides a Java/Jedis code sample for custom connection‑pool configuration.
This article explains the concept of streaming queries, introduces MyBatis' Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or the @Transactional annotation—to keep the database connection alive during iteration.
This comprehensive guide walks you through MongoDB fundamentals, connection strings, creating databases and collections, inserting, updating, deleting, querying documents with AND/OR logic, advanced range and regex queries, and powerful aggregation pipelines including sorting and grouping.
