This guide walks through installing MySQL on Windows, Linux and macOS, configuring security settings, creating the first database and tables, and demonstrates basic queries, updates and deletions with concrete command‑line examples.
This article explains the common reasons Spring transactions become ineffective or fail to roll back—such as wrong method visibility, final modifiers, self‑invocation, non‑Spring beans, multithreading, unsupported table engines, misconfigured propagation, swallowed exceptions, and improper rollback settings—while providing practical code solutions and best‑practice recommendations.
This article introduces a generic asynchronous processing SDK for Java back‑ends, explaining its design principles, advantages, component architecture, database schema, configuration via Apollo, usage steps, and practical demonstrations, while providing complete code snippets and a GitHub repository for reference.
MySQL 9.6 shifts foreign‑key checks and cascade handling from the InnoDB storage engine to the SQL engine, eliminating hidden changes, improving binary‑log visibility, and delivering full‑log replication and analytics without sacrificing performance.
The article argues that the SaaS model is collapsing as AI agents can replace traditional front‑end, back‑end, and middleware layers, driving a shift toward a simple Agent + Database architecture, reviving CLI tools, and redefining the role of GUIs in the era of large language models.
The article argues that the SaaS model is dying as AI agents become universal translators, flattening the traditional middle layers of frontend, backend, and middleware, leading to a new software paradigm where only agents and databases remain, while CLI tools experience a resurgence.
This guide explains how to integrate the PostGIS spatial extension into a Kingbase database running in Docker, covering prerequisite communication with support, extracting the extension files, copying necessary binaries, restarting the container, and verifying the installation with sample queries.
This article examines the double‑write consistency problem between databases and caches like Redis, explains why naïve cache‑first or DB‑first updates can cause stale or phantom data under high concurrency, and evaluates four practical solutions with detailed trade‑offs and recommended retry mechanisms.
This guide shows how to use PHP's mysqli_num_rows function to obtain the number of rows returned by a MySQL query, including connection setup, error handling, executing a SELECT statement, retrieving the count, and important considerations when the query fails.
MySQL 9.6.0 introduces a modular audit log system, GTID replication overhaul, InnoDB enhancements, hardened security components, richer JSON view controls, logging upgrades, Shell extensions, and numerous bug fixes, all aimed at improving performance, flexibility, and enterprise‑grade reliability.
The article details a step‑by‑step migration from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains why the conversion error for java.time.LocalDateTime appears after the switch, shows how to trace the root cause through stack traces, upgrades the mysql‑connector‑java to 5.1.37 (and later 5.1.42) to resolve the issue, and shares broader lessons about component upgrades and unexpected bugs.
The article details a MySQL kernel‑level merged‑seckill optimization that replaces traditional queue‑based flash‑sale handling, achieving up to 5.5× higher TPS (up to 23,543 TPS on 128 threads) and sustaining 1.5W+ orders per second, while remaining transparent to applications and preserving compatibility with existing SQL.
This guide shows how to set up MySQL InnoDB ReplicaSet, start MySQL Router 8.2, configure read/write split routing, and verify that reads are directed to replicas while writes go to the primary instance, all without modifying application code.
This article explains MySQL transaction fundamentals, illustrates a banking transfer scenario, details the ACID properties, explores dirty reads, non‑repeatable reads and phantom reads, and compares the four SQL‑92 isolation levels with practical code examples and InnoDB behavior.
This guide enumerates frequent misconceptions in SQL performance—from over‑indexing and SELECT * misuse to improper transaction handling and outdated monitoring practices—explains why they hurt efficiency, and provides concrete, version‑aware solutions to optimize queries, schema design, and database operations.
This guide explains why InnoDB fuzzy queries lose indexes, introduces MySQL full‑text search with inverted indexes, shows how to create and use full‑text indexes via CREATE TABLE and ALTER statements, and demonstrates natural language, boolean, and query‑expansion modes with practical SQL examples.
The MySQL Server repository on GitHub has seen no code commits for over three months, sparking concerns about Oracle's strategic shift, recent large‑scale layoffs, and the future sustainability of the community‑driven open‑source database.
This article explains how MySQL implements indexes with B+Tree structures, why they outperform full table scans, the internal layout of leaf and internal nodes, insertion and split mechanics, range‑query processing, and practical optimization tips for clustered and secondary indexes.
When MySQL replication falls behind, common culprits include oversized buffer pools, backup‑induced MDL waits, large transactions, slow queries, parallel replication quirks, and network issues, and this guide offers concrete configuration adjustments to restore sync and improve performance.
This article walks through a series of practical backend techniques—batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction management, pagination, and lock granularity—to dramatically reduce API response times from several seconds to just a few milliseconds.
The article explains that count(1) and count(*) produce identical results and similar execution plans, while count(column) skips NULL values; it also compares their performance under various table schemas and provides a MySQL example demonstrating these differences.
This article explains the fundamental differences between DELETE, TRUNCATE, and DROP, covering interview expectations, underlying mechanisms, performance impacts, transaction safety, best‑practice usage scenarios, and common pitfalls to help candidates choose the right command for any database task.
This article details a Redis bucket‑based inventory deduction architecture that guarantees strong consistency while eliminating over‑sell and under‑sell, boosting hot‑spot deduction TPS and stability through a merge‑commit process and comprehensive module design.
This guide presents a comprehensive collection of essential MySQL commands, covering connection management, database creation and selection, table definition and alteration, CRUD operations, query optimization techniques, performance monitoring, and user permission handling, providing clear examples for each command.
This community roundup reviews the 2025 release of the SCALE open‑source LLM‑SQL benchmark, SQLE platform updates, curated video playlists, a curated list of the year's ten best database articles, and provides reference links for further exploration.
This article breaks down Redis's nine data types, explains the underlying structures and typical scenarios for each, compares best‑practice usage, highlights interview focus points, and warns about common misconceptions to help developers choose the most efficient storage solution.
This article presents ten classic SQL interview questions ranging from simple GROUP BY and LIMIT usage to complex window functions and session generation, each accompanied by detailed problem statements, reasoning steps, and complete query solutions for data extraction and analysis.
An in‑depth post‑mortem of a real Go microservice outage reveals how committing a DB transaction before publishing a RabbitMQ event caused duplicate charges, and demonstrates how adopting the Transactional Outbox pattern restores atomicity, prevents ghost bugs, and improves reliability.
This article explains how Redis master‑slave replication provides hot backup, read‑write separation, high availability, and horizontal scaling by detailing its three‑stage workflow, full and partial synchronization mechanisms, key configuration options, and practical analogies for clear understanding.
This guide shows how to connect to a MySQL database in PHP, execute a SELECT query, and use the mysqli_num_rows function to obtain the number of rows returned, including error handling and proper connection closure.
The article examines how PostgreSQL’s latest pgvector 0.8.0 release adds iterative index scans and smart query planning, enabling fully free vector search within an existing relational database, compares performance, cost, and architecture against dedicated vector databases like Pinecone, and outlines migration steps and best‑practice guidelines.
This tutorial walks through MySQL table joins—INNER, LEFT, RIGHT, and FULL OUTER—using clear diagrams, step‑by‑step SQL examples, and sample data, helping readers understand each join type, its result set, and how to emulate full outer joins in MySQL 5.7.
This article analyzes MyBatis-Flex, highlighting its lightweight, flexible, and powerful design, compares its feature set and performance against MyBatis-Plus and Fluent-MyBatis, lists supported databases, and provides a step‑by‑step quick‑start guide with code examples for Spring Boot integration.
To reliably handle RocketMQ's at-least-once delivery semantics, this guide explains why duplicate consumption is inevitable, outlines three defensive layers—Redis‑based idempotency, database unique constraints, and state‑machine checks—provides production‑grade Java code, and details ACK/retry strategies and monitoring practices for robust systems.
MyBatis-Flex is a lightweight, high-performance MyBatis enhancement offering flexible CRUD, advanced QueryWrapper, extensive database support, and benchmarked speeds up to ten times faster than MyBatis-Plus, with a step-by-step quick-start guide covering table creation, Maven setup, Spring Boot configuration, entity mapping, and usage examples.
This article walks through the strengths, typical use cases, and Python connection code for relational databases (MySQL, PostgreSQL, SQLite), NoSQL stores (MongoDB, Redis, Neo4j), cloud‑native options (DynamoDB), and emerging vector databases such as Milvus, helping you decide which fits your project.
Despite five years of hype around HTAP databases, most enterprises continue to run OLTP and OLAP on separate systems because of performance trade‑offs, data consistency challenges, higher operational complexity, migration costs, and the fact that real‑time analytics is needed only in a small fraction of use cases.
Rudis v0.2.0 introduces a major architecture overhaul, upgraded Tokio runtime, shared‑nothing threading, master‑slave replication, transaction support, and a refactored KEYS command that boosts performance by up to 99.55% for large data sets.
This comprehensive guide explores MySQL’s layered architecture, core components, storage engines, and detailed SQL language structures, while providing practical commands, optimization techniques, security best practices, and operational procedures for administrators to efficiently manage, tune, and secure MySQL databases.
This article introduces Yii Database 2.0—a modernized PHP database abstraction layer with new drivers, enhanced type safety, and powerful features—then walks through Composer installation, basic connection setup, and practical query, insert, and transaction examples.
This article explains the design and implementation of Ctrip's Data Replication Center (DRC), a MySQL‑based high‑availability system that solves cross‑region data loop, progress tracking, concurrency, DDL handling, and conflict resolution to achieve low‑latency, reliable data replication for global travel services.
This guide explains why MySQL backup verification is essential, outlines three pre‑restore checks, provides a step‑by‑step manual recovery procedure for single databases, and introduces a production‑grade Bash script that automates one‑click restoration with safety prompts and logging.
This guide explains why MySQL data protection is critical, outlines backup strategies, compares built‑in tools like mysqldump and mysqlpump with third‑party solutions such as Percona XtraBackup, and provides practical scripts, scheduling tips, verification methods, and recovery procedures to ensure reliable, secure database backups.
This report evaluates the professional‑grade LLMs Gemini 3 Pro and DeepSeek‑V3.2‑Exp on three SQL‑related dimensions—understanding, optimization, and dialect conversion—using the SCALE benchmark, presenting detailed scores, strengths, weaknesses, and practical recommendations for database engineers and decision makers.
This article compares SQLite and PostgreSQL, presents detailed SQLite version timelines and OS compatibility tables, explains the differences between rollback‑journal and WAL concurrency models, shows a simple multi‑process lock test, and concludes that SQLite 3.45 is the most suitable choice for modern Linux, macOS, Android and iOS deployments.
This guide presents a fully automated MySQL backup script that securely filters system databases, compresses backups with gzip, logs each operation, automatically removes expired files, and includes step‑by‑step configuration, deployment, scheduling, troubleshooting, and optimization tips for production environments.
This article walks through the challenges of using goInception with OceanBase‑MySQL tenants, details the code modifications required to parse OB's Query Plan, shows how to expose the enhanced engine via a Python wrapper, and presents validation results demonstrating accurate, low‑latency SQL auditing.
This article explains Redis master‑slave replication, covering its purpose for data redundancy, read/write separation, and high availability, and details the full‑synchronization and incremental‑synchronization processes with step‑by‑step diagrams.
This article explains a flash‑sale system architecture from seven dimensions—including Nginx + CDN, routing with Redis, MQ clustering, business logic, read‑write‑separated databases, security controls, and page‑level optimizations—while providing concrete Nginx configs, Redis lock strategies, and database transaction tips to handle massive concurrent requests.
The article provides an in‑depth technical analysis of DongSQL V1.1.0, detailing its RETURNING clause, Hint extensions, CCL concurrency control, Statement Outline, single‑point query bypass, thread‑pool redesign, and benchmark results that show performance gains up to 215% in e‑commerce workloads.
This article explains how implicit type conversion can silently invalidate database indexes, outlines the underlying rules and type‑precedence logic, provides real‑world MySQL examples, shows how to detect the issue with EXPLAIN, and offers concrete best‑practice solutions.
This article deeply explores MySQL transaction isolation levels, explaining ACID principles, the three concurrency problems (dirty read, non‑repeatable read, phantom read), the SQL standard isolation tiers, InnoDB's MVCC and locking mechanisms, practical implementation details for each level, and guidance on choosing and configuring the appropriate isolation level for real‑world applications.
This article presents ten practical MySQL interview questions covering consecutive‑login detection, efficient pagination, top‑salary per department, customers without orders, cumulative sales, recursive cycle detection, pivoting rows to columns, duplicate removal, and user retention, each with complete SQL statements, underlying principles, and performance considerations.
The article reviews MongoDB 8.2’s major upgrades, highlighting up to 36% read throughput gains, 59% write speed improvements, 200% faster time‑series aggregation, 50‑fold faster shard rebalancing, enhanced queryable encryption, native vector search, multi‑cloud Atlas support, and AI‑driven capabilities such as hybrid search and the MongoDB AMP platform.
When logging into a new MySQL 8.4 instance with a non‑existent user, one login attempt yields a "Plugin 'mysql_native_password' is not loaded" error while another returns the usual "Access denied", a difference caused by MySQL's hidden decoy‑user mechanism that randomizes authentication plugins for nonexistent accounts.
This guide explains why OBD 3.6.0 mistakenly removes the primary tenant when deleting a standby tenant, demonstrates the issue with step‑by‑step commands and outputs, and provides a reliable procedure—decoupling, dropping, or failover—to safely delete or promote standby tenants.
This article provides a comprehensive guide to MySQL’s three essential logs—redo, undo, and binlog—detailing their hierarchy, purposes, write mechanisms, configuration parameters, and how they cooperate during transaction processing and replication, while also offering troubleshooting tips for common issues.
This article compares four pagination techniques—basic LIMIT‑OFFSET, primary‑key based filtering, has‑more scrolling, and Elasticsearch pagination—explaining their implementations, advantages, drawbacks, and when each should be chosen for efficient data retrieval.
This article details the three‑year evolution of a self‑built Redis service, covering its massive scale, architectural redesign, migration from LB to a custom DRedis SDK, same‑city active‑active near‑read support, Redis‑server version upgrades, instance specifications, proxy rate‑limiting, and extensive automation that together boost performance while cutting costs.
This article explains Redis master‑slave replication, detailing the full synchronization process that creates an RDB snapshot and streams buffered writes, as well as the incremental synchronization that resumes after a disconnection using PSYNC and the replication backlog.
This article explains why offset‑based pagination can cause duplicate or missing records when data changes, compares three practical solutions—including cursor pagination with timestamps and IDs, fixed‑window timestamp filtering, and Elasticsearch search_after—and provides concrete SQL and code examples along with their trade‑offs and suitable scenarios.
This article systematically compares Elasticsearch, Open Distro, OpenSearch, and Easysearch, covering their origins, licensing, feature sets, performance benchmarks, Chinese‑language support, deployment and operational considerations, and provides guidance on which solution fits different business and compliance scenarios.
ClickHouse 25.10 introduces a suite of enhancements—including 20 JOIN performance upgrades, lazy column replication, Bloom filter runtime filters, disjunction push‑down, automatic column statistics, the QBit vector type, expanded SQL operators, negative LIMIT/OFFSET, Arrow Flight support, and delayed secondary index materialization—backed by detailed benchmarks and contributor acknowledgments.
The article explains why using the KEYS command in Redis is a blocking operation that can cripple production systems, demonstrates the safe, incremental SCAN approach, and proposes an index‑based architecture or replica scans for high‑frequency or offline key‑lookup scenarios.
This article presents a comprehensive set of SQL performance guidelines, covering index creation, avoiding costly operators, rewriting predicates, using proper joins, limiting temporary objects, and best practices for query design to prevent full table scans and improve overall database efficiency.
This article explains why batch tasks significantly affect system and database performance, and outlines three key strategies—task simplification, resource and performance tuning, and proactive monitoring with fault recovery—to design and optimize batch jobs effectively in enterprise development.
This article explains how to handle large‑scale data insertion with multithreading in Spring, why @Transactional fails in child threads, and demonstrates two approaches—manual SqlSession control and thread‑pool execution—to guarantee atomic rollback across all threads.
A Java backend service was unexpectedly showing a three‑day unblocking date instead of two, due to a one‑second overflow when converting LocalDateTime to java.util.Date for a PostgreSQL timestamp column, and the article walks through diagnosis, replication, and two practical fixes.
Learn how to connect to MongoDB using PyMongo, create databases and collections, and perform essential CRUD operations—including inserting single or multiple documents, querying with filters and regex, updating records with update_one and update_many, counting, sorting, pagination, and deleting—complete with Python code examples.
Redis on ARM64 platforms may abort startup with a warning about a kernel COW bug when Transparent Huge Pages are enabled, risking RDB corruption; this guide explains the underlying issue, when it’s safe to ignore the warning, and provides two solutions—disabling THP or configuring ignore‑warnings—to ensure safe operation.
A massive MySQL table ran out of INT auto‑increment IDs due to high concurrency, leading to insert failures; the article analyzes the root cause, evaluates three remediation strategies, and details the eventual migration to BIGINT with performance monitoring and code snippets.
The article explains how Dimensional Query Language (DQL) replaces traditional multi‑table JOIN syntax with object‑dot notation and dimension‑alignment concepts, offering simpler, more business‑focused queries for BI scenarios, and demonstrates its implementation through concrete SQL examples and a real‑world engine integration.
This tutorial walks through installing MongoDB and PyMongo, establishing a connection, selecting databases and collections, and demonstrates how to insert, query, count, sort, skip, limit, update, and delete documents using both legacy and modern PyMongo methods, complete with code examples and operator references.
This article examines MySQL InnoDB deadlocks by analyzing error logs, explaining the two‑phase locking protocol and various lock types, demonstrates how to reproduce a deadlock scenario, categorizes lock behaviors, and offers practical strategies to prevent and monitor deadlocks in database applications.
This article compiles 50 detailed IT operations projects across infrastructure, cloud, containers, automation, monitoring, security, databases, networking, disaster recovery and DevOps, each with scenario, tech stack, implementation steps and quantifiable results to help you craft standout résumé entries.
MyBatis-Flex is a lightweight, high‑performance MyBatis enhancement offering flexible query building, extensive database support, and features like multi‑table joins, logical deletion, and data auditing; the article compares it with MyBatis‑Plus, presents benchmark results, lists supported databases, and provides a step‑by‑step Spring Boot integration guide.
This guide walks you through a systematic Laravel performance optimization process—from diagnosing bottlenecks with Debugbar and logs, through database query tuning, caching strategies, code-level refinements, to server‑level tweaks—ensuring faster response times for growing PHP applications.
This article explains MySQL's sorting mechanisms, comparing index sorting and filesort, detailing memory and disk phases, single‑row and double‑row strategies, and provides practical optimization tips such as proper index design and buffer configuration.
This step‑by‑step guide shows how to add the Yandex repository, install ClickHouse server and client on Rocky Linux or CentOS, configure the service, test local connections, create databases, enable remote access, and verify the setup, all within 15‑20 minutes.
This article examines how MySQL's lock mechanisms and transaction isolation levels can cause deadlocks during high‑concurrency inserts, presents a real‑world case study, walks through log analysis and testing, and offers practical strategies to diagnose, prevent, and resolve such deadlocks.
This article provides a detailed overview of MySQL’s four‑layer architecture—including the client, server, storage engine, and system file layers—explaining each layer’s responsibilities, key modules, and the role of various built‑in and third‑party storage engines.
This comprehensive guide explains the core concepts of transactions, local and distributed transaction models, the CAP theorem, various distributed transaction solutions such as 2PC, TCC, reliable messaging, and maximum effort notifications, and compares their trade‑offs for modern microservice architectures.
This article explains MySQL master‑slave replication, covering its purpose for high availability, key features like real‑time disaster backup and read‑write separation, and the three essential steps—binlog recording on the master, I/O thread transfer to the relay log, and SQL thread replay on the slave.
This article explores the challenges of fuzzy searching encrypted data, categorizes three implementation approaches—naïve, conventional, and advanced—examines their trade‑offs, provides practical examples and performance calculations, and offers recommendations for secure and efficient query solutions.
Learn how to use PHP’s mysqli_num_rows function to retrieve the number of rows returned by a MySQL query, with a complete example that shows connecting to the database, executing a SELECT statement, handling errors, and outputting the row count.
This article explains why using LIMIT on sharded tables can crash databases, then introduces three practical pagination tricks—anchor pagination, shard‑mark method, and reverse pagination—detailing their workflows, performance benefits, and common pitfalls for backend developers.
This article explains the structure and resources of the MongoDB global community, details the elite MongoDB Champions program, outlines how to become a Champion, and highlights the professional and technical benefits of participation for developers and database professionals.
This article explains how veDB-Search provides a one‑stop hybrid search service that combines vector, full‑text, and scalar queries using only SQL, reducing development complexity and operational overhead for AI agents and large‑scale AI applications.
This article introduces the BIRD-CRITIC benchmark, a comprehensive SQL diagnostic dataset spanning multiple dialects, evaluates large language models' ability to repair real-world database queries, and discusses its design, multi‑dialect support, data quality processes, and experimental results.
This tutorial shows how to download MySQL DEB bundles, extract them, resolve dependencies, and install MySQL 8.0 or 8.4 on Ubuntu 20.04/22.04/24.04 and Debian 12 using dpkg, with detailed command sequences and screenshots for each step.
This tutorial walks you through establishing MySQL connections in PHP using both the mysqli extension and PDO, covering procedural and object‑oriented code, prepared statements, error handling, and proper connection closure for robust backend development.
This article provides a comprehensive, cross‑platform tutorial for downloading MySQL RPM bundles, installing required dependencies, using rpm or yum to install MySQL on various RHEL‑compatible distributions, starting the service, retrieving the temporary root password, and securely changing it to a permanent one.
This guide provides a comprehensive collection of essential MySQL commands covering database creation, table schema management, data manipulation, user permissions, performance monitoring, and backup/restore procedures, offering a practical reference for developers and administrators.
This article explains MySQL’s native JSON data type introduced in 5.7, covering its binary storage format, built‑in functions, generated‑column indexing, performance advantages over string storage, and detailed CRUD examples with SQL syntax and practical code snippets.
This comprehensive guide walks you through a systematic methodology for diagnosing and fixing MySQL slow queries, covering proper log configuration, EXPLAIN analysis, index design, query rewriting, table restructuring, and practical caching techniques, while highlighting common misconceptions and real‑world case studies.
This article explains why using traditional LIMIT pagination on sharded databases can cause full‑shard scans and memory‑intensive sorting, and introduces three practical alternatives—anchor pagination, shard‑mark pagination, and reverse pagination—detailing their implementation steps, performance benefits, and common pitfalls to avoid.
SQLite, often dismissed as a toy, proves its robustness by adding powerful SQL capabilities in 2018—including boolean literals, window functions, FILTER clauses, upsert syntax, and column renaming—making it a viable choice for production workloads despite lacking a network layer.
This article examines three categories of techniques—naïve, conventional, and advanced—for enabling fuzzy queries on encrypted data, evaluates their pros and cons, provides implementation details, performance considerations, and references to real‑world solutions, guiding developers toward secure and efficient search strategies.
MySQL query optimization involves three distinct index processing stages—Index Key, Index Filter, and Table Filter—each handling different parts of condition matching and data retrieval, and mastering their roles and execution flow can dramatically improve query performance, especially with index condition pushdown.
This guide walks you through preparing the environment, choosing a data‑sync method, configuring both master and slave servers, verifying replication, troubleshooting common issues, and applying advanced settings to achieve a reliable, monitorable MySQL 5.7 master‑slave setup.
