An in‑depth guide explains MySQL replication fundamentals, compares asynchronous, semi‑synchronous, and fully synchronous modes, and details the binlog‑based architecture with its I/O, log dump, and SQL threads, helping readers understand how replication improves scalability and data safety.
Easy-Query is a Java ORM framework offering strong-typed, database-agnostic CRUD operations, complex SQL generation, multi-table joins, group awareness, and extensive function support, demonstrated through numerous code examples covering queries, joins, subqueries, pagination, and advanced features like enum handling and anonymous type alternatives.
This article explains how to design database tables, build management pages, and develop add, edit, and delete functionalities in PHP to control coupon activity rules for an online store, including logical constraints during checkout.
This article provides a comprehensive tutorial on installing RedisInsight, configuring its environment variables, running it as a service or in Kubernetes, and using its GUI features to monitor and manage Redis instances, complete with code examples and deployment YAML.
This article explains how MySQL InnoDB implements full‑text search using inverted indexes, shows how to create and drop FULLTEXT indexes, and demonstrates natural language, boolean, and query‑expansion search modes with concrete SQL examples and operator details.
This article walks through building a functional Redis server in Go, focusing on transaction support (MULTI, EXEC, WATCH, UNWATCH, DISCARD), using locks for atomicity, version tracking for watch, and an undo‑log mechanism for rollback, with code examples and demo screenshots.
An in‑depth tutorial walks through the five core SQL language families—DDL, DML, DQL, DCL, and TCL—explaining their purposes, key commands, and practical examples, while highlighting differences and usage tips for database schema definition, data manipulation, querying, permission control, and transaction management.
Version 8.3 of MySQL introduces tagged GTID replication, a selectable JSON EXPLAIN format version, enhanced thread‑pool plugin information, changes to binlog transaction dependency tracking and new CMake options, while removing several C API functions, the FLUSH HOSTS statement, and outdated replication flags.
This article walks through the common slow Excel‑to‑DB import pattern, shows why it becomes a bottleneck, and presents three progressive optimizations—including caching, asynchronous multi‑threaded reading, and double‑async processing—along with detailed Spring @Async thread‑pool configuration and EasyExcel alternatives, all illustrated with complete Java code samples.
This comprehensive guide walks through Redis's core data structures—including strings, lists, sets, sorted sets, hashes, HyperLogLog, bitmaps, streams, and geospatial indexes—explaining their characteristics and providing concrete command‑line examples to help developers select and use the right structure for their applications.
This article provides a concise overview of China’s Xinchuang (information technology innovation) ecosystem, explaining the roles and classifications of operating systems, middleware, databases, and firmware, while highlighting global OS market shares and the strategic importance of each layer for national information security.
Taobao’s shopping cart was scaled and optimized by raising the item limit to 380, deploying the cloud‑native in‑memory read‑only replica tairSQL for read‑write separation, pre‑computing promotions, compressing payloads, caching data, redesigning the protocol, introducing response‑streaming APIs, and parallelizing per‑item processing with Java’s ForkJoinPool, dramatically cutting latency during traffic spikes.
This article explains the concept of database read‑write separation, why it improves performance in high‑concurrency scenarios, when to apply it, the underlying master‑slave replication mechanism, and provides a MySQL example illustrating the steps of replication and its benefits for scalability and availability.
This article details Baidu Cloud's BTS semi‑structured storage system, covering its three‑generation evolution, three‑layer architecture, performance optimizations, high‑availability mechanisms, and real‑world use cases such as autonomous driving and large‑scale system monitoring.
A sudden Redis outage caused a shopping homepage to take 20 seconds to load, prompting a rapid analysis of data‑volume growth, a post‑mortem of the fallback logic, and the design of a combined local‑cache, MongoDB, and database strategy to restore fast, reliable service.
This article walks through the problem of sharing a single database across pre‑release, gray, and production environments, explains why adding an env column to dozens of tables is error‑prone, and demonstrates a MyBatis interceptor‑based solution with custom annotations that isolates data while preserving backward compatibility.
This article reveals the most common Redis pitfalls—including unexpected key expiration loss, O(1) commands that block or cause OOM, master‑slave synchronization quirks, and persistence bugs—while providing practical guidance to avoid each issue and keep your cache performant and reliable.
This article explains Redis's two persistence mechanisms—Append Only File (AOF) and RDB snapshots—detailing their operation, advantages, risks, write‑back strategies, rewrite process, and how to choose the appropriate method for performance and reliability requirements.
This article explains how Just‑In‑Time (JIT) compilation, particularly via the Gandiva expression compiler built on LLVM and Apache Arrow, can dramatically accelerate database expression evaluation by transforming abstract syntax trees into native vectorized code, addressing traditional interpretation bottlenecks and improving CPU‑bound query performance.
Explore 17 practical Python scripts that automate tasks ranging from file management and web scraping to email handling, database interaction, system monitoring, and cloud services, enabling developers and analysts to boost productivity, reduce errors, and streamline workflows across diverse domains.
The article explains why counting rows in large MySQL tables—especially with InnoDB—can become slow, compares COUNT() performance across storage engines and query forms, and offers optimization tactics such as using metadata counts, EXPLAIN estimates, a dedicated counting table, or periodic batch processing for accurate or approximate results.
This guide explains MySQL stored procedure flow‑control constructs—including IF, CASE, LOOP, WHILE, REPEAT, LEAVE and ITERATE—detailing their syntax, usage patterns, and practical examples such as salary adjustments and conditional logic, helping developers implement complex database operations efficiently.
This article explains how KeyDB, a Redis fork, redesigns the single‑threaded key‑value store into a multi‑threaded system, covering its thread model, connection management, fastlock mechanism, and active‑replica features while maintaining full Redis API compatibility.
This article explains how to migrate a specific Redis database (db8) to another server's db15 by writing a Python script that batches keys, tracks progress, estimates remaining time, and verifies the migration results.
Three real-world operations mishaps are recounted—a mistaken system‑time change that logged out thousands of users, an accidental bulk delete of database accounts, and a failed glibc downgrade that stalled a software release—illustrating the cascading impact of small errors and the urgent remediation steps taken.
This article walks through a real‑world case of a slow MySQL query that took 8 seconds, explains how the original use of EXISTS and NOT EXISTS caused performance bottlenecks, and details two successive rewrites—first using JOIN + GROUP BY, then replacing NOT EXISTS with NOT IN—bringing execution time down to 0.7 seconds while highlighting key indexing and testing lessons.
This newsletter announces the SQLE 3.2401.0-pre1 release with automatic data masking, shares recent community development work, outlines upcoming plans, and curates several technical articles covering MySQL EXPLAIN enhancements, transaction fundamentals, hardware considerations for database stability, consistent backup techniques, and efficient JDBC connection testing.
This article introduces Redis Stack’s RedisJSON module, explains its JSONPath syntax, details the full set of JSON commands for handling various data types, provides practical code examples, and highlights how RedisJSON enables Redis to function as a document, full‑text, and vector search database.
This guide explains MySQL stored procedures, covering their definition, benefits, parameter types, creation syntax, delimiter handling, multiple practical examples, calling conventions, debugging tips, and hands‑on exercises, enabling developers to efficiently write, test, and manage reusable SQL routines.
Redis implements its own Simple Dynamic String (SDS) instead of plain C strings because SDS stores length for O(1) queries, pre‑allocates extra space and lazily reuses freed bytes, prevents buffer overflows, handles binary data, and uniformly backs all string keys, values and container elements.
This article provides a comprehensive, step‑by‑step analysis of MyBatis, covering its core features, three‑layer architecture, configuration file parsing, dynamic proxy generation, and the detailed process of executing SQL statements within the framework.
This article walks through the design of a billion‑user group chat platform, covering functional and non‑functional requirements, core components, database schema, face‑to‑face group creation, message flow, storage strategies, and performance‑optimizing techniques such as clustering, message queues, multithreading, and Redis caching.
This article walks through a MySQL 5.6 scenario where a sub‑query that scans 700,000 rows takes over 30,000 seconds, then demonstrates how adding single‑column and composite indexes, rewriting the query as a join, and analyzing execution plans reduces the runtime to milliseconds, highlighting best‑practice indexing techniques.
This article explains the new EXPLAIN INTO clause introduced in MySQL 8.1 for storing JSON‑formatted EXPLAIN output in a user variable and the EXPLAIN FOR SCHEMA clause added in MySQL 8.2 for running EXPLAIN on other schemas, showing how to extract costs with JSON functions and automate collection with stored procedures.
This article explains how MySQL indexes work, compares clustered and non‑clustered indexes, outlines their advantages and disadvantages, and provides practical design guidelines to improve query performance and maintainability.
This article introduces SpringBoot 3.2's JdbcClient, explains how to add the dependency, inject it, and demonstrates fluent‑API query and insert operations—including positional, named, map‑based parameters and custom RowMapper—showing how to perform CRUD without heavyweight ORM frameworks.
ByConity 0.3.0 introduces a new inverted index supporting Chinese tokenization, a shared‑storage leader election mechanism, enhanced cold‑read performance via Prefetch and adaptive mark allocation, and an upgraded ELT pipeline with BSP mode, all detailed with implementation steps, code examples, and future roadmap.
This article explains why traditional LIKE queries fail on encrypted sensitive fields, analyzes common scenarios, and presents four practical solutions—including tokenized ciphertext mapping—along with environment setup, Maven dependencies, and complete Spring Boot code to enable secure fuzzy searches on encrypted data.
This guide walks through Redis fundamentals, covering how data persists after restarts, core key operations, database selection, serialization, expiration handling, key movement, random retrieval, renaming, and how to check the number of configured databases, all with practical command examples and visual illustrations.
This article introduces Spring Boot 3.2's new JdbcClient, explains its fluent API style, shows how to add the dependency, inject it, and perform various query and insert operations with code examples, highlighting its advantages over traditional ORM frameworks.
This article explains the nature of NULL in MySQL, demonstrates why comparisons with = or != fail, shows the correct IS NULL/IS NOT NULL syntax, and discusses how NULL behaves with DISTINCT, GROUP BY, ORDER BY, and aggregate functions.
StarRocks 3.2, released on December 21, 2023, introduces major usability upgrades—including optimized random bucketing, fast schema evolution, PIPE import, HTTP SQL API, runtime profiling, enhanced storage‑compute separation, data lake analysis, and advanced materialized view capabilities—while refining existing features such as indexing, catalog support, and export syntax.
This guide introduces Spring Boot 3.2's new JdbcClient, explains how to add the dependency, inject it, and perform fluent, chainable CRUD operations—including queries by ID, custom conditions, named parameters, map parameters, row mapping, and inserts—while highlighting its advantages over traditional ORM tools.
This article explains the most common MySQL table join types—including INNER, LEFT, RIGHT, FULL OUTER, and exclusive joins—by creating sample order and customer tables, inserting data, visualizing each join with diagrams, and providing the exact SQL statements and query results.
This article examines the storage challenges faced by large‑scale internet services and evaluates popular MySQL middleware solutions—ProxySQL, MaxScale, DBProxy, MyCat, and TDDL—by mapping business requirements to their core features and capabilities.
KeyDB is a high‑performance, multithreaded fork of Redis that retains full protocol compatibility while adding features like Active Replication, flash storage support, and advanced locking, offering up to double the query throughput and reduced latency on the same hardware.
This article explains how to boost PHP application performance by using caching functions, efficient array functions, selective database queries, and recursive functions, providing clear code examples for each technique.
This article explains how to build a two-level comment system for an Android app by designing a comment database schema, creating DAO and repository layers, and using nested RecyclerViews with adapters to display primary comments and their replies, including code snippets and layout illustrations.
This article presents thirteen practical Redis performance‑optimization rules, covering avoidance of slow commands, proper key expiration handling, data‑structure selection, persistence tuning, hardware considerations, pipeline usage, client‑side improvements, and distributed architectures such as replication, sentinel and Redis Cluster, to help developers achieve significant speed gains.
This comprehensive guide explores MySQL transaction fundamentals, the ACID properties, various isolation levels, concurrency issues like dirty, non‑repeatable, and phantom reads, and dives deep into MVCC implementation, hidden fields, undo logs, and read views to help developers write reliable, consistent database code.
This tutorial walks through creating a lightweight Go ORM—covering a custom logger, converting structs to table metadata, implementing basic CRUD operations, handling transactions, and adding hook callbacks—while exposing the core Session data structure and providing a GitHub reference.
This article presents a comprehensive overview of precise deduplication in Meituan's Doris database, detailing the underlying bitmap data structures, aggregation bottlenecks, and a series of optimizations—including memory management, fast union, orthogonal encoding, and vectorized engine integration—that together achieve significant performance gains in high‑cardinality scenarios.
This tutorial explains how to create a MySQL database on a Linux system using PHP's mysqli extension, covering prerequisite installations, establishing a connection to the MySQL server, and executing SQL statements to create the database, with complete code examples and instructions for customizing credentials.
This article provides a step‑by‑step guide for installing the open‑source SQLE 3.0 SQL quality management platform using both RPM packages and Docker containers, covering environment preparation, configuration file adjustments, service startup, common issues, and troubleshooting tips.
This article explains the various lock types in MySQL—including global, table, row, metadata, and intent locks—how they work under InnoDB, demonstrates lock acquisition with SQL examples, and provides practical guidance for detecting and resolving deadlocks in production environments.
This article details how SelectDB’s inverted‑index, Variant data type, and sampling capabilities were integrated into GuanceDB to replace Elasticsearch, achieving up to 70% storage cost reduction, 2‑4× query speed improvement, and a ten‑fold overall cost‑performance boost for log analytics and observability workloads.
This article introduces MyBatis‑Flex, a lightweight and high‑performance MyBatis enhancement framework, outlines its key features, compares it with similar tools, presents benchmark results, lists supported databases, and provides a step‑by‑step quick‑start tutorial with complete code examples for Spring Boot integration.
This article explains MySQL index types, B+Tree structures, secondary indexes, and demonstrates how enabling Index Condition Pushdown (ICP) can accelerate a query on a 6‑million‑row table by roughly ninety times, providing detailed setup, commands, and performance results.
A junior ops engineer mistakenly set the production server clock ahead by a year, causing thousands of user accounts to expire, triggering a large‑scale outage, emergency fixes, financial loss, and harsh career consequences, while highlighting the need for proper permission and change management.
This article traces the 70‑year evolution of databases, examines how the rise of AIGC, cloud computing and AI native architectures are reshaping the industry, and details Baidu Smart Cloud's historical milestones, flagship products such as GaiaDB and PegaDB, and the emerging trends that will drive the next generation of database solutions.
The article critically examines the drawbacks of running production databases inside Docker containers or Kubernetes, arguing that while containers excel for stateless services, they introduce reliability, performance, maintenance, and complexity challenges that make them unsuitable for critical stateful database workloads.
This article explains what NoSQL databases are, outlines their typical use cases and architectural components, compares them with traditional relational databases across storage, scalability, query, and transaction aspects, and highlights the advantages and trade‑offs to consider when choosing a data solution.
The Pika community announced version 3.5.2, fixing long‑standing bugs and adding features such as Redis transaction support, a cache layer for hot‑cold data separation, dynamic Codis‑Proxy configuration, and performance improvements, while also outlining the planned enhancements for the upcoming 3.5.3 release.
This article explains MySQL's explicit and implicit locking mechanisms, illustrates how transaction isolation levels affect lock scope, provides practical SQL examples for various scenarios, and offers guidelines on when to apply pessimistic locks versus optimistic approaches to maintain database performance.
This article walks through the step‑by‑step evolution from raw JDBC to the MyBatis framework, explaining why JDBC should be wrapped, how MyBatis improves connection handling, SQL management, dynamic statements, result mapping, caching, and overall architecture with concrete code examples.
This guide presents a comprehensive set of SQL statements for the idc_evaluating database, illustrating how to retrieve rows by province or IP, count and delete active IPs, describe table structures, perform conditional aggregations, and execute inner‑join queries with calculated fields.
This article examines Baidu Search's content storage team's HTAP table storage system, detailing the challenges of supporting massive OLAP workloads on an OLTP‑oriented backend, the architectural split into Neptune and Saturn, storage‑engine optimizations such as row partitioning and dynamic columns, and a SQL‑like KQL framework for compute and scheduling.
This article experimentally compares the performance of JOIN and IN approaches for retrieving order and user data in MySQL, showing that JOIN is faster on small datasets while IN may become costly with large data volumes, and discusses code implementations and practical conclusions.
This article explains how to migrate a 240 GB MongoDB replica set by performing a full backup with oplog, extracting the incremental oplog timestamp, and then applying incremental backup and restore scripts to minimize downtime, while providing detailed shell commands and precautionary tips.
This tutorial explains how to add enum types to GORM models in Go, covering definition of enum values, model integration, CRUD operations using enums, and alternative approaches such as string fields, custom types, and GORM's built‑in enum tag to enhance type safety and database reliability.
This article debunks the common belief that MySQL VARCHAR can store up to 65535 characters, showing how the true limit depends on the chosen character set, NULLability, column count, and row‑format details, and explains how oversized values are stored or require TEXT/BLOB types.
This article explains why MySQL master‑slave replication can become delayed, outlines the differences between DDL and DML, shows how to diagnose lag with show slave status, and provides architectural, hardware, and configuration solutions—including semi‑synchronous replication and tuning parameters—to reduce latency.
This tutorial walks you through creating mount directories, configuring redis.conf, running a Redis container with Docker, and verifying the setup using redis-cli and a visual client, providing all necessary commands and explanations for a successful deployment.
SQL database queries are essential skills for data analysts, enabling them to extract, transform, and analyze data from databases through various operations like filtering, sorting, aggregation, and joining.
This article explains Python's multithreading model, covering thread creation, synchronization, data sharing, and provides practical code examples for sending concurrent API requests, downloading files, running test cases, reading files, and inserting records into a SQLite database.
This tutorial demonstrates how to enable and use MySQL 8.2 read/write splitting with MySQL‑Connector/Python in an InnoDB Cluster, covering cluster status inspection, autocommit configuration, routing attributes, DML testing, and transaction handling.
This article reviews essential PHP development practices—including user authentication, database interaction, file handling, front‑end/back‑end communication, and error logging—while offering concrete optimization tips such as password hashing, RBAC, indexing, caching, connection pooling, and proper logging to improve application quality and performance.
This article explains why a DELETE statement with a table alias fails in MySQL 5.7, shows the correct syntax without alias, compares the DELETE syntax of MySQL 5.7 and 8.0, and concludes that alias support in single‑table DELETE was added starting with version 8.0.16.
This tutorial demonstrates how to enable MySQL 8.2's transparent read/write splitting with InnoDB Cluster, configure MySQL Router, use MySQL Connector/Python for read‑only and read‑write queries, test DML statements, and manage transactions across primary and secondary nodes.
This article explains how PHP can connect to various databases, execute queries, fetch results, insert or update records, close connections, handle errors, and address security concerns, providing code examples for both MySQLi and PDO extensions.
This article explains the principles and practical designs of high‑performance database clusters, covering read/write separation, master‑slave replication lag, distribution mechanisms, sharding (both vertical and horizontal), business‑level partitioning, and the role of NoSQL technologies such as key‑value stores, document databases, columnar databases, and full‑text search engines.
This article demonstrates why @Transactional fails in multithreaded Spring services, presents a thread‑pool based solution using manual SqlSession control to achieve full rollback across child threads, and provides complete code examples and test results illustrating both failure and successful transaction handling.
This article examines why MySQL permits creating multiple identical indexes on the same column, demonstrates the behavior through several tests, compares it with Oracle's stricter restrictions, and explains how the optimizer selects indexes, highlighting practical implications for database design.
This article explains MySQL's locking mechanisms, covering when locks are applied, how they are acquired—including explicit and implicit locks—and guidelines on when to use or avoid them, with examples of lock behavior under different isolation levels and query scenarios.
An urgent overnight incident revealed a MySQL server’s CPU soaring to 400% due to poorly written queries, prompting a detailed analysis of execution plans, identification of costly operations like filesort and temporary tables, and concrete recommendations for query and team improvements.
This article explains why MySQL backups are essential, defines RTO and RPO, compares physical and logical backup methods, describes snapshot, binary‑log, incremental and differential strategies, and provides best‑practice recommendations and example commands for reliable backup and recovery.
The AIKOS community weekly newsletter shares the SQLE 3.0 release, recent development work, upcoming plans, curated MySQL and OceanBase technical articles, industry highlights, and announcements for future events, providing valuable insights for database practitioners and open‑source contributors.
This article introduces NoSQL databases, explains their core concepts, typical use cases, architectural components, and contrasts them with relational databases, helping readers understand when and why to choose NoSQL solutions for large‑scale, unstructured data workloads.
The article analyzes the importance of system stability during major sales promotions, presents data‑driven insights on traffic and revenue, identifies key challenges such as massive traffic, data volume, and complex workflows, and offers comprehensive operational, application, storage, and monitoring measures to guarantee reliable performance under extreme load.
This article explains what a MySQL deadlock is, shows a concrete example using two conflicting transactions on a simple test table, demonstrates how to detect the deadlock with InnoDB status output, and provides practical tips for preventing deadlocks in production systems.
This article explains how to parse OceanBase logs to trace the tenant freeze dump workflow, detailing the roles and log sequences of the freeze check thread, LSFreeze, Flush, DagScheduler, and MiniMerge threads, and illustrating each step with actual log excerpts and code snippets.
This article examines MySQL's comprehensive lock taxonomy, starting from common row and table locks, then delving into lesser‑known mechanisms such as global locks, intention locks, auto‑increment locks, and Latch, while explaining their commands, use‑cases, and performance implications for developers and DBAs.
The article walks through diagnosing a 10‑second backend loading delay, explains connection‑pool concepts, introduces Alibaba's Druid pool with its monitoring UI, shows how to identify and optimize slow SQL queries using DISTINCT and indexes, and provides step‑by‑step SpringBoot integration instructions.
This article explains why full‑text search is needed, how InnoDB implements it with inverted indexes, the syntax for creating and using full‑text indexes, the different query modes (natural language, boolean, query expansion), and how to delete full‑text indexes in MySQL.
Improving web page load speed is crucial for user experience, and PHP developers can employ methods such as caching, script and stylesheet compression, database query optimization, reducing HTTP requests, using CDNs, output compression, cache plugins, asynchronous loading, and image optimization to significantly enhance performance.
This article presents a collection of SQL statements—including SELECT, DELETE, DESCRIBE, and JOIN queries—targeting various tables in the idc_evaluating database, accompanied by detailed English explanations of their purpose, syntax, and result set structure.
This article explains MySQL's various lock mechanisms—including shared (S) and exclusive (X) locks, intention locks, record, gap, next‑key, and insert‑intention locks—illustrates their behavior with SQL examples, analyzes a concurrent insert deadlock scenario, and offers practical mitigation strategies.
This article explains how Redis implements geospatial indexing with GEOADD and GEORADIUS commands, walks through their source‑code implementations, describes the underlying geohash calculations and nine‑cell grid search strategy, and derives the O(N + log M) time complexity for nearby‑people queries.
A Java ToB system struggled to meet a 500 requests‑per‑second target, revealing hidden bottlenecks such as slow SQL, excessive logging, thread‑pool misconfiguration, high CPU usage from Spring bean creation, and improper Redis usage, which were systematically identified and mitigated.
This article explains essential techniques for managing concurrent access and race conditions in PHP, covering mutex locks, semaphores, atomic operations, queue-based processing, database access optimization, and transaction management to improve system reliability and performance.
