This article explains MySQL's internal execution process—including the connector, cache, parser, optimizer, and executor—describes privilege tables and verification, discusses query caching removal, outlines logical SQL execution order, and provides practical tips for ordering WHERE conditions to improve performance.
This article explains the fundamentals of database transactions, the ACID properties, Spring's @Transactional support, various propagation behaviors and isolation levels, and provides practical code examples for both declarative and programmatic transaction management in Java backend development.
This article provides a detailed guide on optimizing MySQL performance, covering SQL statement tuning, index usage, table design normalization, system configuration, hardware choices, and the internal architecture of MySQL to help developers write faster and more efficient queries.
This article outlines comprehensive guidelines for Alibaba Cloud Redis, covering readable and concise key naming, value size limits, appropriate data types, key lifecycle management, safe command usage, client connection pooling, encryption, eviction policies, and tools for synchronization, big‑key detection, and efficient deletion.
This article describes how a multi‑layered cache system—including a DAO‑level Redis cache, shared cache components, and global cache planning—was designed, implemented, and deployed to reduce database QPS by over 80%, cut response latency, and improve overall system stability in a high‑traffic e‑commerce platform.
This comprehensive guide explores MongoDB’s core features—including schema flexibility, high availability, sharding, storage engine internals, indexing, and performance tuning—while providing practical examples, configuration tips, and best‑practice recommendations for developers and architects seeking to efficiently deploy and operate MongoDB in production environments.
This article explains the concept of MySQL auto‑increment locks, describes different insertion methods and lock modes, analyzes how InnoDB allocates and manages auto‑increment IDs—including simple, bulk, and mixed inserts—and provides source‑code insights, practical experiments, and mitigation strategies for ID continuity issues.
This article explains the concept of a schema—from its Greek origins and psychological meaning to its role as metadata in databases and Kubernetes—detailing different database schema models, Kubernetes resource definitions, and how to extend and register custom schemas in Go.
This article explains how Redis RDB persistence works, detailing the save configuration parameters, snapshot generation methods, differences between SAVE and BGSAVE, storage locations, and the advantages and disadvantages of using RDB snapshots.
This guide explains how to identify when Redis is slow, measure baseline latency, monitor slow commands and latency, troubleshoot network, fork, huge pages, swap, AOF, expiration, and big keys, and provides a practical checklist of solutions.
This article compiles frequently asked questions and detailed solutions covering Apache Doris operational problems, data handling errors, and SQL query issues, providing step‑by‑step guidance, configuration tips, and command examples to help administrators troubleshoot and maintain a stable Doris cluster.
The article explains why Oracle can release MySQL under a dual GPLv2/commercial licensing model, how the GPL works, the impossibility of changing licenses for existing versions, and proposes creating a domestically controlled GPL‑v2 MySQL fork to avoid future licensing risks.
This article provides an in‑depth tutorial on Activiti 7 workflow management, covering workflow concepts, system architecture, BPMN modeling, environment setup, Maven dependencies, database configuration, deployment methods, process execution, task handling, and historical data retrieval for Java backend development.
This article details Meituan's journey from rapid database growth and operational bottlenecks to a multi‑year roadmap that combines platform‑level monitoring, rule‑based and AI‑enhanced root‑cause analysis, and automated remediation, ultimately delivering measurable improvements in alert accuracy, recall rates, and overall database reliability.
This article provides a comprehensive overview of MySQL's internal execution flow—from client connection handling, permission verification, caching, parsing, optimization, and execution—to the detailed SQL execution order, helping readers grasp how queries are processed and optimized within the database engine.
This tutorial explains why read/write splitting is useful, shows step‑by‑step how to build a MySQL master‑slave cluster with Docker, configure the master and slave instances, and then use Sharding‑JDBC to transparently route writes to the master and reads to the slave.
This article provides a comprehensive, step‑by‑step explanation of MySQL InnoDB's MVCC mechanism, covering its fundamentals, the role of Undo Log and Read View, and how it enables repeatable‑read and read‑committed isolation levels while preventing dirty reads and other concurrency anomalies.
The article walks through building a lightweight Java ORM framework from scratch, showing JDBC drawbacks, defining XML configuration and mapper files, implementing core components like SqlSessionFactory, SimpleExecutor, and reflection‑based parameter and result mapping, and demonstrating a working test that returns POJOs.
This article explains the complete MySQL query processing pipeline, covering the connector, authentication, privilege checks, caching, parser, optimizer, executor, and the detailed SQL execution order with examples of each stage, helping readers understand and optimize their SQL statements.
This article explains InnoDB’s role as a MySQL storage engine, how it reads and writes data using 16 KB pages, the mechanics of row formats—especially the dynamic format—and why varchar columns are limited to 16383 characters, illustrated with SQL examples and diagrams.
This guide walks beginners through downloading, installing, and configuring MySQL 8.0.28 on Windows and Linux, covering environment variables, service management, password recovery, user and role creation, and JDBC connection setup with Maven, providing detailed commands, code snippets, and troubleshooting tips for a complete setup.
This article explains how to replace raw PyMySQL usage with SQLAlchemy ORM in Python, covering environment setup, database connection initialization, MVC‑style project structure, model class definitions, field attributes, session handling with context managers, and practical code examples for saving and querying data.
This tutorial walks through building a PostgreSQL audit plugin for the SQLE platform using Go, covering project setup, minimal plugin code, adding a SELECT‑star prohibition rule, and implementing a configurable rule that limits table column counts, complete with deployment and testing instructions.
This article walks through MySQL's InnoDB storage engine, explaining how pages, locality, skip‑list concepts and B+‑tree structures work together to make indexes efficient, and shows how clustered, non‑clustered and covering indexes affect query performance and I/O behavior.
This article demonstrates how a functional, persistent key‑value store can be created with just two shell commands—one to append data and another to retrieve the latest entry—while explaining the underlying grep and sed techniques, performance trade‑offs, and basic indexing concepts.
This article outlines thirteen practical Redis performance‑optimization rules, covering command complexity, key expiration, data‑structure selection, persistence settings, hardware choices, clustering, and memory‑fragmentation monitoring to help developers maximize throughput and reduce latency in production environments.
This article demonstrates how to efficiently update up to 50,000 MySQL records in a Spring Boot‑MyBatis application by comparing simple loops, manual transaction control, multithreaded execution with CountDownLatch coordination, and union‑based batch updates, while analyzing performance and connection‑pool considerations.
Redis 7.0, now officially stable for production, introduces nearly 50 new commands, major features like Redis Functions, ACLv2, command introspection, and Sharded Pub/Sub, while enhancing memory, compute, network, and storage subsystems for better performance and efficiency.
This article explains why using COUNT(*) for simple existence queries is unnecessary and demonstrates how replacing it with SELECT 1 LIMIT 1 in SQL, together with a Java DAO method that checks for non‑null results, can significantly improve performance and reduce index complexity.
This article explains how MySQL InnoDB implements full‑text search using inverted indexes, covers creation and usage of full‑text indexes, demonstrates natural language, boolean, and query‑expansion modes, and shows how to delete full‑text indexes with practical SQL examples.
This article explains what SQL window functions are, shows their syntax, and provides step‑by‑step basic and advanced examples—including how to rank rows within groups and reset rankings when key columns change—complete with runnable SQL scripts and result screenshots.
This article explains why using SELECT 1 with LIMIT 1 is more efficient than COUNT(*) for existence checks in SQL, shows the typical count‑based approach, provides optimized SQL and Java examples, and discusses the performance benefits and reduced indexing requirements.
This article provides a comprehensive technical guide on Redis performance, covering single‑threaded characteristics, master‑slave replication, Sentinel high‑availability mechanisms, Redis Cluster architecture, configuration steps, code examples, and alternative middleware solutions for scaling and fault tolerance.
This article explains Redis 6's client‑side caching feature, describing its purpose, the two tracking modes (default and broadcast), a forward mode for RESP 2 clients, their advantages over traditional remote caching, and provides step‑by‑step command‑line examples with code snippets.
Bean Searcher is an open‑source Java library that dramatically simplifies backend list retrieval by offering a high‑performance search engine with built‑in multi‑table joins, pagination, sorting, field selection and aggregation, allowing developers to implement complex queries in just one line of code.
This article explains how SQL injection can exploit a Java Spring course‑selection system by concatenating user input into SQL statements, demonstrates various injection techniques such as always‑true conditions and UNION queries, and provides multiple defensive measures including prepared statements, type checking, permission restrictions, and request‑parameter filtering.
This article demonstrates how to dramatically speed up updating tens of thousands of records in a Spring‑MyBatis application by switching from automatic per‑operation commits to manual transaction control, applying multithreaded processing, tuning the Hikari connection pool, and using SQL UNION‑based batch updates.
This article provides a comprehensive tutorial on using ShardingSphere‑JDBC, configuring MySQL master‑slave replication with Docker, explaining binlog and redo‑log mechanisms, demonstrating two‑phase commit, and detailing Sharding‑JDBC read/write splitting and sharding configurations with code examples.
The February 2022 DB‑Engines ranking shows Snowflake’s rapid rise, a sharp decline for Oracle, MySQL and Microsoft SQL Server, stable positions for Elasticsearch, and detailed score trends across relational, key‑value, document, time‑series and graph databases, highlighting five popularity metrics used for the assessment.
In MySQL, an UPDATE that modifies no actual data returns an affected‑rows count of zero, making it unreliable for business logic that distinguishes between unchanged rows and non‑existent records, so developers should avoid using this count for critical decisions.
Redis 7.0 has been officially launched, bringing nearly 50 new commands, major enhancements like Redis Functions, ACLv2, command introspection, and Sharded Pub/Sub, plus extensive performance and stability improvements across memory, compute, networking, and storage subsystems.
This article explains the structures of B+ trees and skip lists, compares their insertion and search behaviors, and shows why MySQL prefers B+ trees for disk‑based indexing while Redis adopts skip lists for in‑memory operations.
This article introduces Redis, explains how to install it on various platforms, demonstrates integrating Redis with Spring Boot using Spring Cache annotations, configures connection pools for Lettuce and Jedis, and provides custom Redis service implementations for flexible cache operations.
This article analyzes a MySQL InnoDB lock wait timeout error, explains how gap locks cause blocked inserts and phantom reads under repeatable‑read isolation, and offers optimization strategies such as primary‑key deletions, while concluding with a recruitment invitation for the Zero technology team.
The article walks through building a minimal SQLite‑style database in Go, covering memory‑disk page storage, B‑tree indexing, simple SQL parsing for INSERT and SELECT, row serialization, a pager that flushes pages, and a basic REPL, while highlighting current single‑page limits and future extensions.
This article provides a comprehensive guide to optimizing MySQL queries and indexes, covering best practices such as avoiding subqueries, using IN instead of OR, proper LIMIT usage, eliminating unnecessary ORDER BY, leveraging UNION ALL, batch inserts, selective column retrieval, distinguishing IN and EXISTS, improving GROUP BY, using numeric fields, optimizing JOINs, and applying index rules like left‑most prefix, avoiding functions on indexed columns, handling type conversions, covering indexes, and effective use of composite and prefix indexes.
This article outlines several frequent MySQL query pitfalls—including missing table aliases in multi‑table operations, unsupported FULL JOIN syntax, unexpected REPLACE INTO side effects, auto‑increment edge cases, data‑type mismatches, nondeterministic functions, and warning‑driven query behavior—providing examples and best‑practice recommendations to prevent data loss and performance issues.
This article introduces FaunaDB, explains how to create a free account and access key, and provides a step‑by‑step Python tutorial that demonstrates creating a collection and performing all CRUD operations with concise code examples.
Apache Doris (incubating) announced its 1.0 release on April 18, 2022, featuring a new vectorized execution engine, Hive external tables, Lateral View syntax, Z‑Order indexing, SeaTunnel integration, numerous performance optimizations, new bitmap functions, security enhancements, and detailed upgrade instructions for users.
This article explains the concept of streaming queries, introduces MyBatis's Cursor interface with its key methods, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep database connections open and avoid cursor‑closed errors in Spring MVC applications.
This article explains the structures of B+ trees and skip lists, compares their read and write performance, and details why MySQL chooses B+ trees for indexing while Redis and RocksDB prefer skip lists, highlighting trade‑offs in disk I/O, fan‑out, and balancing overhead.
This article examines frequent SQL anti‑patterns—such as inefficient LIMIT usage, implicit type conversion, suboptimal UPDATE/DELETE joins, mixed ordering, unnecessary EXISTS clauses, condition push‑down failures, early limiting, and intermediate result handling—and provides rewritten queries that dramatically improve performance.
This guide walks through installing PostgreSQL 14 on a CentOS server via a shell script, covering repository setup, package installation, initialization, user and database creation, remote‑connection configuration, firewall adjustments, service verification, and connecting with Navicat.
This article recounts the end‑to‑end experience of planning, executing, and reviewing a database sharding project for a high‑traffic order platform, detailing pre‑implementation risk assessment, the detailed testing lifecycle, gray‑release strategies, performance validation, and post‑mortem lessons learned.
The article recounts how a simple misclick made the popular HTTPie repository private, instantly erasing over 54,000 GitHub stars, and extracts practical lessons on UI warnings, backup policies, and repository‑management best practices for developers and platform teams.
This article explains Redis's two expiration strategies—periodic active deletion and lazy deletion—detailing how the EXPIRE command works, the new NX/XX/GT/LT options introduced in version 7.0, the impact of unsynchronized clocks, and the underlying implementation code.
This article explains three common situations where Spring's @Transactional annotation becomes ineffective—non‑public methods, internal self‑calls, and swallowed exceptions—detailing the underlying proxy mechanism, code examples, test results, and practical workarounds to ensure proper transaction management.
A recent hardware failure left a physical server's disk read‑only, causing Redis to hang; this article explains the AOF mechanism, its potential pitfalls, log strategies, and practical steps to prevent and mitigate such issues in production environments.
This article explains the mathematical and computer‑science definition of idempotency, why it is essential for reliable distributed services, how to handle timeout scenarios, and presents eight concrete design patterns—including unique IDs, database constraints, token mechanisms, optimistic/pessimistic locks, and distributed locks—along with code examples and HTTP method analysis.
This article provides a comprehensive overview of ClickHouse, an open‑source column‑oriented MPP analytical database, covering its advantages and drawbacks, key features, typical use cases, data access flow, installation steps, core directories, indexes, data types, database and table engines, as well as detailed cluster architecture and deployment patterns.
This guide walks through using the Postgres Operator UI to create, start, update, and delete PostgreSQL clusters on Kubernetes, covering UI navigation, configuration options, troubleshooting steps, and limitations, with links to detailed documentation.
The article explains why using IN and NOT IN in SQL can lead to poor performance, incorrect results with NULLs, and index misuse, and demonstrates how EXISTS, NOT EXISTS, and JOIN provide safer and faster alternatives for database queries.
This article investigates MySQL's recommendation against UUID primary keys by creating three tables—auto‑increment, UUID, and random (snowflake) keys—running insert and query benchmarks with SpringBoot/JdbcTemplate, analyzing index structures, and discussing the performance trade‑offs and security considerations of each key strategy.
This article explains how to replace parent‑id based tree storage with the nested set model, showing SQL queries to retrieve descendants, count them, detect leaf nodes, and perform insert, delete, and other operations, plus a JavaScript example for rebuilding the hierarchy.
This article provides a thorough guide to SQL fundamentals—including SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY, LIMIT, aggregate functions, joins, set operations, and Oracle-specific objects—followed by a collection of common interview questions with detailed solutions, top‑N queries, and row‑to‑column transformations, while also containing promotional notes for related resources.
This article explains how to use the nested set (left‑right) model to efficiently query, count, and manipulate hierarchical department data in MySQL, providing SQL examples for retrieving descendants, ancestors, leaf detection, as well as insert, delete, and JavaScript tree‑building techniques.
This article explains why SQL performance degrades as data grows, outlines a step‑by‑step optimization workflow—including slow‑query detection, EXPLAIN analysis, profiling, optimizer tracing, and corrective actions—while detailing type and extra fields, index usage, and practical scenarios such as large pagination, IN‑order‑by, range queries, and complex joins.
Redis 7.0-rc3 introduces new cluster commands, configuration ordering changes, ACL restrictions, function load adjustments, performance optimizations, enhanced CLI behavior, expanded INFO fields, module API extensions, and a comprehensive set of bug fixes, providing developers with important updates and potential migration considerations.
This article explains MySQL high‑availability concepts, defines HA, RPO and RTO, outlines common HA architectures such as master‑slave+VIP, MHA and MGR+Proxy, and details AutoHome's evolution from simple master‑slave setups to a container‑based MGR solution with automated failover and monitoring platforms.
This article examines the critical role of databases in finance, defines disaster recovery and backup concepts, outlines industry requirements and regulations, analyzes market growth, and compares distributed database disaster‑recovery architectures such as single‑center, city‑level mutual backup, active‑active, and two‑site three‑center solutions.
This article presents a detailed experiment comparing graceful and kill‑9 shutdown methods on a MySQL 5.7 semi‑synchronous master‑slave cluster, analyzes their impact on data consistency, and outlines the official shutdown sequence with practical observations and recommendations for production environments.
This article walks through a real‑world TiDB/TiKV disk‑space alarm case, diagnosing why the GC worker got stuck, how TiCDC’s lingering changefeed caused outdated MVCC versions, and the step‑by‑step commands and monitoring tricks used to restore normal GC and reclaim storage.
Learn how to identify and fix slow MySQL queries by analyzing slow‑query logs, using EXPLAIN, profiling, and optimizer trace, understanding index types and extra flags, and applying practical case‑by‑case optimizations such as index tuning, query rewriting, pagination strategies, and handling large data sets.
This article explains the core components of database systems, including their client‑server architecture, query processing, storage engine modules, classification by storage media (memory vs. disk), and the differences between row‑oriented and column‑oriented data layouts, concluding with future topics to explore.
The article explains how ORM bridges Python objects and relational databases, compares options, and justifies choosing the lightweight Peewee library, then details its workflow—model generation, inserting, updating, deleting, and querying records—showcasing how this approach reduces manual data‑creation time from hours to seconds.
The article analyzes how comprehensive Western sanctions against Russia are prompting China to accelerate self‑reliance in foundational software, examines Oracle's pivotal role in Chinese enterprises, and discusses the strategic, technical, and market obstacles to achieving a successful "de‑IOE" transition.
The article provides a comprehensive overview of Oracle Real Application Cluster (RAC), detailing its two‑part architecture of Clusterware and RAC instances, shared storage configurations, key Clusterware processes, storage options, benefits such as load balancing and high availability, as well as its management and planning considerations.
Streaming queries return an iterator instead of a full result set, reducing memory usage, but require the database connection to stay open; this guide explains MyBatis’s Cursor interface, its methods, common pitfalls like premature closure, and three practical solutions using SqlSessionFactory, TransactionTemplate, or @Transactional to ensure reliable streaming.
This article provides a comprehensive walkthrough of Druid's connection pool lifecycle, detailing how getConnection initiates the process, the role of initialization, filter chains, connection validation, thread‑blocking strategies, and the various guardian threads that add, evict, and recycle connections to ensure performance and stability.
This article explains what streaming queries are, why they save memory compared to pagination, details the MyBatis Cursor interface and its methods, demonstrates how to implement streaming queries with code examples, and presents three solutions—using SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open and prevent cursor‑closed errors.
This article explains InnoDB's lock system in MySQL, covering lock granularity, intent, shared, exclusive and auto‑increment locks, row‑lock types, the underlying C++ structures, lock mode and type encoding, and the compatibility and strength matrices that govern lock acquisition and waiting.
This guide explains how to create a custom annotation and an Aspect in Spring to capture detailed operation logs—including description, table name, parameters, user info, and execution result—and persist them to a database, covering AOP terminology, configuration styles, and complete code examples.
This guide explains the Percona XtraDB Cluster (PXC) architecture, its advantages and limitations, and provides step‑by‑step commands for removing MariaDB, opening firewall ports, disabling SELinux, downloading packages, configuring MySQL, bootstrapping the first node, adding additional nodes, and verifying the cluster status.
This article provides a thorough step‑by‑step guide to identify why Redis latency spikes, covering baseline performance testing, slowlog analysis, big‑key handling, expiration patterns, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, memory fragmentation, network bandwidth, and practical optimization techniques.
ClickHouse‑Keeper, a C++‑based ZooKeeper replacement using the Raft algorithm, offers linearizable reads, compression, and easier deployment; this article explains its advantages, configuration template, startup command, parameter details, health checks, and step‑by‑step migration from ZooKeeper using the ClickHouse‑Keeper‑Converter tool.
This article explains Redis's persistence mechanisms, detailing the snapshot-based RDB approach and the append‑only file (AOF) method, their configuration commands, advantages, disadvantages, and how to choose between them for reliable data durability.
This article explains MySQL high availability concepts, how master‑slave replication works, how to measure and mitigate replication lag, and compares reliable‑first and availability‑first failover strategies with practical experiments on binlog formats.
This article explains how Redis ensures data durability through two persistence methods—Append‑Only File (AOF) and Redis Database (RDB) snapshots—covering their principles, configuration options, risks, rewrite processes, recovery procedures, handling of expired keys, and the hybrid approach introduced in Redis 4.0.
This article explains the four SQL language categories (DDL, DML, DCL, TCL), various backup and recovery types, common MySQL backup methods, and flashback recovery techniques, providing detailed guidance and tool comparisons for database administrators.
This guide walks you through preparing the environment, adding the RadonDB MySQL operator repository, deploying the operator, installing a MySQL cluster, and verifying the deployment on KubeSphere, providing all necessary commands and screenshots for a successful high‑availability setup.
This guide demonstrates how to perform a full MySQL backup, create incremental backups, handle accidental database deletions, and restore the data using Percona XtraBackup on a Linux server, including detailed command-line steps and permission adjustments.
This article explains Redis's two persistence mechanisms—RDB snapshots and AOF append‑only logs—detailing how they work, how to enable them via commands or configuration, their advantages and drawbacks, and guidance on choosing the right method for your workload.
This article explains the concept, syntax, and practical applications of SQL CASE expressions, covering simple and searched forms, row‑to‑column pivots, statistical transformations, conditional SELECT and UPDATE statements, and CHECK constraints, with detailed code examples and best‑practice tips.
The article explains MySQL InnoDB lock scopes and modes—including record, gap, next‑key and insert‑intention locks—illustrates a deadlock caused by concurrent inserts on a distributed lock table, and recommends limiting concurrency, sharding by business key, and splitting lock operations into smaller sub‑transactions to avoid such deadlocks.
RedisOM, the official Redis ORM for Java, lets Spring Boot developers replace RedisTemplate with object‑oriented data handling and built‑in full‑text search, covering JDK 11 setup, Maven dependencies, configuration, entity annotations, repository interfaces, and REST controller examples for managing product data.
This article explains why traditional B‑Tree indexes fail for keyword searches, introduces the concept of inverted indexes, shows how to create and use MySQL InnoDB full‑text indexes with MATCH‑AGAINST in various modes, and covers index maintenance and query‑expansion techniques.
Redis 7.0-rc2 introduces stream consumer group lag tracking, new ACL‑checking APIs, additional command options, extended replies, performance enhancements, and a series of bug fixes, providing a comprehensive update to the open‑source in‑memory database.
This article explains how Redis uses the simple text‑based RESP protocol for client‑server communication, details each reply type, shows how to capture traffic with tcpdump, and dives into the internal C structures and error codes that power Redis commands.
The MHA Re-Edition tool revives the discontinued MHA manager for MySQL, adding GTID‑based failover, password‑only SSH authentication, lightweight binaries, VIP migration, WeChat alerts, remote‑card reboot, and detailed configuration options, with step‑by‑step deployment instructions and sample app1.cnf parameters for high‑availability clusters.
This article explores Redis's persistence mechanisms, detailing how RDB snapshots and AOF logs work, how to configure and trigger them, their advantages and drawbacks, and guidance on choosing the appropriate method for reliable data storage.
