This article explains what MySQL indexes are, how they work, their types—including primary, ordinary, composite, and full‑text indexes—covers B‑Tree and B+Tree structures, page organization, clustering versus non‑clustering indexes, and practical considerations for index design and performance.
This article explains why the KEYS command is dangerous for large keyspaces, introduces the SCAN command and its multithreaded variants, discusses distributed counting strategies, compares built‑in counters and real‑time incremental approaches, and provides guidance on selecting the best solution for your Redis deployment.
This article explains how MySQL's InnoDB engine implements full‑text search using inverted indexes, shows how to create and use full‑text indexes with various query modes, demonstrates Boolean operators and query expansion, and covers index removal techniques.
This article outlines a comprehensive, multi‑layer database audit architecture for financial systems, covering principle‑of‑least‑privilege service accounts, database activity monitoring, log correlation, optional code scanning, API injection detection, regular security drills, and development‑side safeguards to ensure traceable, compliant data access.
This article presents a series of MySQL interview questions and answers that illustrate typical situations where indexes become ineffective—such as leading wildcards in LIKE, NOT IN, NOT EXISTS, functions, inequality operators, OR conditions, mismatched ORDER BY, large result sets, and explains how to analyze execution plans and use FORCE INDEX to improve performance.
This article explains MySQL InnoDB locking mechanisms—including row, record, gap, next‑key, and intention locks—illustrates each type with SQL statements and performance_schema data, and shows how they interact during concurrent transactions.
This article examines a MySQL case where importing a 4 GB tablespace takes 13 minutes, explains why SHOW PROFILE reports most of the time in the System lock stage, and dives into the internal implementation of SHOW PROFILE, data collection, calculation, and the tablespace import code path.
This article explains the evolution of data storage, the fundamentals of computer storage devices, and how database indexes—especially clustered and non‑clustered indexes—leverage binary search to dramatically speed up query performance while outlining their drawbacks and common SQL optimization techniques.
This article provides a comprehensive walkthrough of JDBC for MySQL, covering driver loading, connection creation, statement and prepared statement objects, SQL execution with examples, batch processing, and performance considerations for test engineers using Java.
This article details how Kuaishou dramatically cut storage costs and improved cache efficiency for its core Photo data object by cleaning up redundant JSON fields, applying selective serialization, and performing large‑scale data cleaning, achieving a 25% size reduction, a 2% cache‑hit increase, and multi‑hundred‑TB savings.
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 with connection handling, query execution, result processing, and best‑practice notes.
Learn how to efficiently configure and manage database connections in FastAPI, covering synchronous and asynchronous setups, dependency injection, session handling, and testing strategies, to prevent leaks, boost performance, and ensure scalable, reliable applications.
This comprehensive guide explains the Text2SQL concept, showcases real‑world scenarios, compares three implementation architectures—including a simple prompt‑based method, a LangChain‑based pipeline, and an enterprise‑grade Vanna solution—while providing practical tips, security measures, and advanced enhancements for deploying robust natural‑language‑to‑SQL systems.
This article introduces MySQL's tree‑style execution plan output using EXPLAIN FORMAT=TREE, explains its advantages over traditional and JSON formats, and demonstrates its practical use through eight detailed SQL examples with full plan analysis and performance insights.
This article provides a comprehensive overview of database transactions, explaining ACID properties, transaction states, explicit and implicit transaction control, isolation levels, and how to configure and use them in MySQL with practical SQL examples and code snippets.
Redis 8 has been released under the OSI‑approved AGPLv3 license, reversing its 2024 SSPL shift, and brings up to 87% faster command execution, double the throughput, and integrated modules like JSON, TimeSeries, and the new Vector Sets data type, sparking community debate and competition with Valkey.
This article explains how to use Redis Sorted Sets and Hashes to achieve efficient pagination, fuzzy multi‑condition queries, and their combination, while also discussing performance‑optimisation strategies such as temporary ZSet expiration and data‑freshness handling, before concluding with a brief promotional segment.
This article combines a Meituan salary update with detailed explanations of MySQL indexing strategies, B‑tree variations, ACID transaction properties, isolation levels, caching, handling high‑traffic queries, the Raft consensus algorithm, and an overview of gRPC, providing comprehensive backend development knowledge for interview preparation.
This article walks through the background, reproduction steps, investigation methods, and concrete solution for MySQL metadata lock (MDL) issues that cause DDL statements to hang, and provides practical tips to prevent similar lock problems in production environments.
This article explains what mysqldump is, describes its backup mechanism, lists command‑line options with detailed meanings, provides example commands for exporting databases or tables, and shows how to restore data using both system and source commands.
Redis clusters use two redirection commands—MOVED for permanently migrated hash slots and ASK for temporary redirects during slot migration—explaining their trigger conditions, typical scenarios, and step-by-step client interaction examples, including sample CLI output.
This comprehensive MySQL tutorial covers everything from core concepts and architecture to practical CRUD operations, advanced queries, indexing, transaction control, stored procedures, triggers, replication, performance tuning, backup strategies, and real-world use cases, providing a complete roadmap for developers and DBAs.
This article details a systematic performance test of OceanBase's online DDL capabilities, measuring TPS and QPS impacts across various DDL operations, describing the test environment, scripts, results, and conclusions for reliable database schema changes.
A detailed Oracle 10g case study reveals how excessive log file sync waits, caused by I/O performance problems and frequent log switches on aging mechanical storage, lead to database hangs, and provides step‑by‑step analysis and practical mitigation tips.
This article explains the PFAIL (possible fail) and FAIL (failed) states in Redis clusters, describes the state transition process, demonstrates node failure and automatic failover with command‑line examples, and provides practical insights into cluster health monitoring and recovery.
Redis 8.0, released on May 1 2025, introduces a major license shift to AGPL‑v3, adds eight native data structures—including vector sets, JSON, and time‑series—enhances the query engine with up to 16× performance gains, improves scalability, security, and cloud‑native support, and provides extensive code examples for AI and real‑time analytics.
This article explains why storing dates as strings is inefficient, compares MySQL DATETIME and TIMESTAMP—including storage size, range, timezone handling, and performance—and discusses when to use numeric Unix timestamps or PostgreSQL equivalents for reliable time data management.
This tutorial explains how to build logistics tracking and delivery management features for an e‑commerce platform using PHP, covering database table creation, inserting, updating, and querying of tracking and delivery records with complete code examples.
This article presents a curated collection of practical Spring Boot 3 examples—including JSON parsing, automatic database script execution, custom DataSource configuration, properties/YAML loading, and data binding with validation—complete with code snippets and configuration details for Java backend developers.
This article explains the sequential write process of Undo Log, Redo Log, and Binlog during MySQL transaction execution and commit phases, describes the involved caches, two‑phase commit rationale, and outlines key configuration parameters for each log type.
This article explains the MySQL MY-013129 error, its lack of a fixed message, the code paths that generate it in MySQL 8.0, why it is logged as an ERROR, and practical recommendations for filtering or handling the log entries.
Redis 8.0 GA introduces a suite of new data structures—including a Vector Set for AI, native JSON support, and several probabilistic types—enhances the query engine with secondary indexes and full‑text/vector search, delivers significant performance gains, and re‑embraces open source by adding an OSI‑approved AGPLv3 license.
The article outlines why deleting tens of millions of rows in one statement harms performance and reliability, then presents safe, efficient tactics—such as indexed batch deletes, partition drops, creating a new table, or using TRUNCATE—plus pre‑deletion planning, post‑delete validation, monitoring, and space reclamation.
This article details a real‑world case study of the activity middle‑platform system’s slow‑SQL problem, explaining the definition, causes, and harmful impacts of slow queries, then outlines step‑by‑step mitigation strategies—including data cleanup, partitioning, indexing, query refactoring, and scheduling—to dramatically reduce slow‑SQL occurrences from thousands to double‑digit counts.
The author compares IntelliJ IDEA's built‑in database tool with Navicat for running massive SQL dump files, showing that IDEA consistently achieves higher execution speed, lower CPU usage, and no freezes even on multi‑gigabyte scripts, contrary to common expectations.
This article demonstrates how to use the H2 database with Java 1.8, covering embedded (file and memory) modes, server modes (Web, TCP, PG), mixed mode configurations, required dependencies, and provides complete JUnit test code examples for creating, accessing, and managing tables.
This article explains how to manually migrate a hash slot in a Redis cluster by checking cluster status, setting importing and migrating slots, retrieving keys, using the MIGRATE command, and updating slot assignments across nodes, with detailed command examples and explanations.
This tutorial demonstrates how to connect to a MySQL database in PHP using mysqli_connect, execute queries with mysqli_query, and retrieve each row as an associative array using mysqli_fetch_assoc, providing complete code examples and a full script for efficient backend data handling.
Redis 8.0 marks a major shift with its return to a true open‑source license (AGPLv3), the consolidation of Redis Open Source, a suite of advanced modules like Vector Search and TimeSeries, and a Spring Boot compatibility guide, turning Redis from a simple cache into a versatile data platform.
Redis 8.0 GA introduces a suite of new data structures, AGPLv3 licensing, multithreaded query execution, horizontal scaling, and significant performance gains, positioning Redis as a more powerful in‑memory database for big‑data, AI, and real‑time applications.
This tutorial demonstrates how to configure Spring 6 with JdbcTemplate, create a MySQL database and table, define entity and datasource beans, and perform CRUD operations—including batch updates and callback functions—while also showing integration with the Druid connection pool.
Redis, after a year of closed‑source experiments, reopens its source code with version 8 under AGPLv3, offering developers a choice of three licenses, detailing the CEO's regrets, community backlash, emerging forks, and new performance‑focused features that reshape its future.
Operations engineers struggling with countless Redis commands and opaque data structures can simplify their workflow with five recommended visual tools that turn complex Redis operations into intuitive interfaces, complete with monitoring, cluster support, and cross‑platform clients.
Redis, after a year of closed‑source experiments and a controversial dual‑license strategy, announced its return to open source under AGPLv3 for version 8, sparking intense debate over licensing choices, community trust, and the future direction of the in‑memory database ecosystem.
This article explores the MCP platform’s data service capabilities, detailing its core components—Resources, Prompts, and Tools—and demonstrates how its Text2SQL feature enables natural‑language queries to retrieve table schemas, perform data sampling, and execute complex relational analyses across multiple database tables.
This article traces MySQL’s architectural evolution from single‑node to sharded clusters, explains the fundamentals and classifications of NoSQL databases, and provides a comprehensive guide to Redis—including installation, memory management, and detailed usage of its five core data types with best‑practice considerations.
This article explains MySQL deadlocks by creating a test table, running two concurrent transactions—one using SLEEP to hold a lock and another attempting the same resource—to reproduce a deadlock error, and discusses how this approach aids debugging and understanding of transaction conflicts.
This article explains how Spring Boot's @Transactional annotation automates transaction management, reducing boilerplate code, improving development efficiency, and ensuring data consistency, while also covering its underlying AOP mechanism, configuration options, and practical code examples.
This article explains the process of moving hash slots between nodes in a Redis cluster using the redis-cli --cluster reshard command, detailing the required parameters, interactive steps, and verification of successful slot migration.
This article explains the key Redis cluster configuration options found in redis.conf, detailing required settings such as cluster-enabled, cluster-config-file, and cluster-node-timeout, as well as optional parameters like cluster-slave-validity-factor, migration barrier, full coverage requirement, and read‑when‑down behavior.
This tutorial introduces NoSQL concepts and provides step‑by‑step Python code examples for installing, connecting, inserting, querying, updating, and deleting data in both MongoDB and Redis, highlighting their suitable use cases and key differences.
This article explains the concept of epochs in Redis Cluster, describing the two types—currentEpoch and configEpoch—their roles in versioning and conflict resolution, how they are updated and persisted, and provides example node listings and commands for inspection.
This article explains how Redis cluster nodes use a TCP-based gossip protocol and a dedicated cluster bus to discover each other, detect failures, synchronize configuration, and automatically redirect client commands to the correct node, illustrated with practical command‑line examples.
NativePHP is a third‑party library that enables developers to embed native PHP code within Laravel, allowing execution of CLI commands, file system manipulation, and database operations, thereby simplifying the creation of efficient, flexible desktop applications.
This article analyzes the pain points of inconsistent online‑offline configurations, proposes three synchronization schemes—including timed batch sync, automatic real‑time binlog‑MQ sync, and manual selective sync—compares their applicability, risks and performance, and presents practical deployment results across multiple projects using MySQL and TiDB.
This article introduces several widely used Visual Studio Code extensions for database management—including SQLTools, MSSQL, Database Client, DBCode, DevDb, and MongoDB for VS Code—detailing their features, supported databases, installation steps, and marketplace links to help developers choose the right tool for their workflow.
This guide demonstrates how to horizontally scale a Redis cluster by adding nodes as masters or slaves, configuring them, using redis-cli commands to join or remove nodes, and handling special cases such as removing a failed node, all with practical code examples.
This article explains why using UUID as a primary key in MySQL can degrade insert, update, and query performance due to large index size, unordered values, and frequent index splits, and offers optimization strategies such as ordered UUIDs, binary storage, combined auto‑increment keys, and table partitioning.
This article explains how to create custom MyBatis TypeHandler classes to automatically convert Java objects—such as JSON strings and enum codes—to appropriate JDBC types, simplifying data persistence in Spring Boot applications and improving code maintainability.
When storing dates in MySQL or PostgreSQL, avoid VARCHAR fields and select between DATETIME (no time‑zone, larger range) and TIMESTAMP (UTC conversion, smaller range) based on whether automatic time‑zone handling and the 2038 limit suit your application, with Unix timestamps as a high‑performance alternative.
This article explains how to find the MySQL deadlock log, parse its contents to determine the time, order, and affected rows, identify the lock types and root cause, and provides extended examples of special locking scenarios, all illustrated with real‑world SQL and code snippets.
This article explains why the number in MySQL's int(N) definition does not limit the column's numeric range, demonstrates that int(1) can store the full 4‑byte unsigned range, and shows how the ZEROFILL attribute adds zero‑padding for display purposes.
This article presents a step‑by‑step tutorial for building a Python Tkinter vaccine management application that demonstrates practical CRUD operations, GUI design, and MySQL database integration, providing complete source code, database schema, and detailed explanations for each functional module.
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.
