This article explains the immutable unique node IDs in a Redis cluster, the additional metadata each node maintains, provides a sample `cluster nodes` output, and details the meaning of every field in that output to help with monitoring and interview preparation.
A friend who landed a 16K job in a first‑tier city shares more than 30 interview questions he encountered across ten+ companies, covering JVM internals, performance tuning, concurrency, design patterns, database locking, distributed transactions, and system reliability.
The 18th China Electronics Information Conference will be held in Chengdu from April 17‑21, 2025, featuring the DATA+AI forum that gathers leading academicians and industry experts to discuss data‑AI integration, with detailed speaker biographies, presentation titles, and abstracts covering topics such as large‑model inference, cloud‑edge ultrasound diagnostics, and the future of databases in the AI era.
This article presents a Bash script that automates full MySQL database backups, supports configurable connection parameters, backup storage paths, retention policies, logs operations, and can be scheduled via cron, providing a comprehensive solution for reliable database backup and cleanup.
This article explains how to use PHP's mysqli_num_rows function to retrieve the number of rows returned by a MySQL query, providing a step‑by‑step example that connects to the database, executes a SELECT statement, checks for errors, and outputs the row count.
This guide explains how to connect an Alibaba Cloud Bailei large language model to a MySQL database using MaxKB, create semantic‑to‑SQL nodes, define system roles, and build an AI assistant that can answer operational questions with natural‑language responses and SQL queries.
This article explains how the PHP mysqli_query function works with MySQL, provides a complete example for executing SELECT queries, and discusses its use for INSERT, UPDATE, DELETE operations along with result handling and related fetching functions.
This article demonstrates how to use PHP's mysqli_num_rows function to retrieve the number of rows returned by a MySQL query, including a complete example that connects to the database, executes a SELECT statement, checks for errors, obtains the row count, and outputs the result.
This article explains MySQL's three concurrency types—read‑read, read‑write, and write‑write—describes how InnoDB uses MVCC, shared and exclusive locks, and provides practical examples and code for handling update‑loss and write‑write conflicts with optimistic and pessimistic locking.
This article walks through the complete process of implementing dynamic data source switching in a SpringBoot application, covering the core concepts of thread‑local context, abstract routing, custom annotations with AOP, configuration, code examples, and important considerations such as transaction management and performance.
This article analyzes six common MySQL query performance traps—type conversion, function usage, left‑most prefix, implicit charset conversion, left‑most match, and optimizer mis‑selection—illustrates each with real‑world SQL examples, explains why they degrade performance, and provides concrete remediation steps and verification tools.
This tutorial walks you through checking the OS architecture, preparing the environment, downloading and extracting the MySQL 5.7 ARM package, configuring my.cnf, setting up auto‑start and environment variables, initializing the server, securing the root account, and configuring master‑slave replication on Linux.
This guide explains why Redis clustering is needed for capacity, concurrency and failover, describes Redis 3.0's decentralized cluster architecture, provides step‑by‑step commands to configure, launch and combine six nodes into a cluster, demonstrates slot calculations, client usage with Jedis, and outlines fault recovery, pros and cons, and cleanup procedures.
This guide shows how to encapsulate MySQL connections and CRUD operations in a reusable Python class, integrate it with Pytest for parameterized API tests, return query results as JSON, and add Loguru‑based logging to improve test maintainability and traceability.
This article presents a series of MySQL performance‑tuning techniques—including smarter LIMIT usage, avoiding implicit type conversion, rewriting joins, handling mixed ordering, replacing EXISTS with joins, pushing predicates into subqueries, early row limiting, and using WITH clauses—to dramatically reduce query execution time across common scenarios.
This article presents a hands‑on evaluation of several large language models—including Mistral‑Small, Deepseek‑r1, Llama 3.3 and ChatGPT‑4‑go—on Oracle database bad‑block errors, RAG‑based document retrieval, and log‑driven reasoning, revealing performance gaps, scoring results, and practical DBA implications.
This article examines six common MySQL indexing pitfalls—type mismatches, function usage, left‑prefix violations, implicit charset conversions, range query issues, and optimizer mis‑choices—and provides concrete SQL fixes and verification tools to improve query performance.
This guide walks you through preparing multiple virtual machines, configuring MySQL server IDs, setting up both classic and GTID‑based master‑slave replication, and managing the replication with essential commands, complete with code examples and architecture diagrams.
This article explains the purpose of using the always‑true condition “WHERE 1=1” in MyBatis SQL mappings, demonstrates through EXPLAIN queries that it does not prevent index usage, and recommends a cleaner MyBatis syntax that lets MySQL’s optimizer remove the redundant condition.
This article explains what deadlocks are, outlines the four classic conditions that cause them, provides Java thread and MySQL transaction examples, and offers practical solutions such as consistent lock ordering, timeout settings, batch updates, and shortening transaction duration to prevent deadlocks.
This article explains the concept of MySQL optimistic locking, its underlying version‑or‑timestamp mechanism, and provides step‑by‑step SQL examples for adding a version column, reading data, and safely updating records while handling concurrent modifications.
This article explains why altering a column length in OceanBase may trigger an "Alter charset or collation type not supported" error, analyzes the underlying charset and collation settings, and provides a solution that explicitly specifies charset and collation to ensure successful column expansion across versions.
This article explains where MySQL stores its data on disk, how the InnoDB engine organizes files, pages, extents, segments, and rows, and details the Compact, Dynamic, and Compressed row formats, including null‑value handling and overflow mechanisms.
The article explains why data masking is essential for protecting sensitive information, then details three implementation methods—SQL, Java (with open‑source plugins), and the MyBatis‑Mate‑Sensitive‑Jackson ORM extension—comparing their principles, code examples, advantages, limitations, performance, suitable scenarios, and cost considerations.
The article explains why the widely embedded SQLite database relies on the Fossil version‑control system rather than Git, highlighting Fossil’s simplicity, better situational awareness, lower management overhead, and more suitable user experience for SQLite’s needs.
Learn how to dramatically improve FastAPI application speed by implementing asynchronous endpoints, database connection pooling, Redis caching, query optimization, Gzip compression, background tasks, performance monitoring, CDN static file serving, and faster JSON serialization with ujson, each illustrated with practical code examples.
The article details how StarRocks extends the Apache ORC C++ library to decrypt column‑level encrypted ORC files, describing the file hierarchy, AES‑128‑CTR key handling, the query‑time master‑key retrieval, a decorator‑based decryption/decompression pipeline, and the block‑skip‑read mechanism that enables efficient predicate push‑down.
This article examines a failure case of OceanBase's OBLogProxy service in Binlog mode, detailing background conditions, status checks, log analysis, the root cause of timestamp mismatches, and provides step‑by‑step remediation procedures to restore normal binlog processing.
This article explains MySQL's replication mechanism, detailing master‑slave architecture, key threads, binlog formats (statement, row, mixed), common application scenarios such as backup, read/write splitting, and data migration, and highlights important considerations like network latency, consistency, delay, and security.
This article compiles the most frequently asked MySQL interview questions, covering fundamentals, storage engines, SQL optimization, indexing, transaction handling, replication, sharding, and performance troubleshooting to help readers master both theory and practical usage.
This guide explains how to use Redis cluster key tags to align multiple keys to the same slot, enabling multi-key commands like MGET, and includes step‑by‑step examples of connecting, setting keys, checking slots, encountering CROSSSLOT errors, and resolving them with tagged keys.
This article explains what MySQL indexes are, how they work, their advantages and drawbacks, the different index types—including primary, ordinary, composite, full‑text, clustered and non‑clustered—and compares B‑Tree with B+Tree structures to help you design faster, more efficient queries.
This article explains how MySQL InnoDB full‑text search works, covering inverted index structures, creation and deletion of full‑text indexes, query syntax for natural language, boolean, and query‑expansion modes, relevance calculation, and practical examples with SQL code.
This article provides a comprehensive guide to Redis Cluster, covering its background, overall architecture, deployment steps, configuration templates, cluster creation commands, basic key‑value operations, high‑availability testing, and how to manually assign master‑slave relationships for robust distributed caching.
The article explains why adding conditions after a LEFT JOIN using AND does not filter the number of rows returned, clarifies the distinct roles of ON and WHERE clauses, and demonstrates the behavior with multiple SQL examples and visual illustrations.
This article demonstrates how to build a dynamic data source switching mechanism in Spring Boot by leveraging ThreadLocal for thread‑scoped context and AbstractRoutingDataSource for routing, covering manual implementation, annotation‑driven switching, and runtime addition of new data sources.
This article provides a step‑by‑step guide to essential MySQL operations, covering connection methods, database creation and deletion, user management, password changes, data manipulation, query techniques, indexing strategies, performance tips, and backup procedures, all illustrated with complete command examples.
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 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.
