This article explains how to use PHP's mysqli_num_rows function to retrieve the number of rows returned by a MySQL query, including a complete example with connection handling, error checking, and output of the row count.
This article explains why plain LIKE searches become slow on large MySQL tables, shows how prefix patterns and string functions like LOCATE, POSITION, INSTR, and FIND_IN_SET can leverage indexes, and provides a comprehensive list of thirty practical SQL optimization techniques to dramatically improve query performance.
This article presents a configurable OLAP framework that streamlines multi‑dimensional, multi‑metric analysis by separating core and interaction domains, using metadata‑driven modeling, runtime request handling, and Maven‑based integration to accelerate development and improve query performance.
This article details how to switch a SpringBoot‑MyBatisPlus‑MySQL application to PostgreSQL, covering driver addition, JDBC configuration changes, numerous SQL and type‑conversion pitfalls, helper scripts for bulk column updates, and essential migration notes.
The article defines large database transactions, explains their performance and replication risks, offers practical guidelines to avoid them, demonstrates a MySQL example that creates and repeatedly inserts data to illustrate growing execution time, and discusses challenges and solutions for handling massive tables in high‑traffic environments.
A daily million‑order e‑commerce platform only generates about 30 TPS, making inventory‑deduction and oversell concerns trivial and solvable with a single atomic SQL update rather than complex distributed solutions.
This article explores how to retrieve sales statistics for multiple business units and their associated products in MySQL, compares loop‑based, OR‑concatenated, mixed‑filter, and SQL‑92 row‑comparison techniques, and explains why the row‑comparison method was ultimately chosen for its performance and compliance with development constraints.
This guide walks you through using Alibaba Cloud EMR Serverless Spark to ingest OSS‑HDFS audit logs, create source, detail, and summary data‑warehouse tables with Spark SQL, orchestrate the tasks in a workflow, and schedule daily IP‑traffic analysis, complete with code snippets and UI screenshots.
This article walks through a real‑world Oracle index failure, explains why indexes become UNUSABLE, shows how to clean residual metadata, rebuild the index safely, outlines common causes for both regular and partitioned tables, and provides SQL scripts for monitoring invalid indexes.
Learn how to create a Go-based command-line tool that accepts user-supplied parameters to connect to an Oracle database using the loginWithServiceName function, execute arbitrary SQL queries, and display results, complete with full source code, flag parsing, and error handling.
The article compares MySQL and PostgreSQL, covering their histories, architecture hierarchies, benchmark performance on SELECT/INSERT/UPDATE, suitable use cases, and summarizes PostgreSQL’s advantages and disadvantages relative to MySQL, providing guidance for choosing the appropriate database.
Amid the rise of vector databases, AI, and cloud computing, this article explains how PostgreSQL’s flexibility, extensibility, and open‑source community are reigniting SQL’s relevance in 2024, uniting OLTP and OLAP workloads and positioning PostgreSQL as the versatile backbone for modern data management.
SQLite 3.46.0 introduces extensive PRAGMA enhancements, new date‑time modifiers, support for underscore digits in numeric literals, a json_pretty() function, significant query planner optimizations, improved JSON handling, and the ability to use large hexadecimal literals as column defaults, all while maintaining its public‑domain, self‑contained nature.
The article explains what constitutes an SQL problem, presents a typical case of performance degradation caused by mismatched character sets, and outlines how the SQLE platform can help developers, testers, and DBAs systematically manage and improve SQL quality throughout the software lifecycle.
This article explains the concept of MySQL master‑slave replication, outlines its advantages and drawbacks, and provides a step‑by‑step guide—including downloading MySQL 8.0, configuring my.cnf on master and slave servers, creating replication users, setting up replication parameters, and using Laravel for read‑write splitting—complete with all necessary shell and SQL commands.
This article presents a comprehensive guide to MySQL table design, covering naming conventions, appropriate data types, primary key strategies, field length choices, logical deletion, common fields, indexing rules, normalization trade‑offs, storage engine selection, time type recommendations, and SQL optimization tips.
This article demonstrates how to diagnose and resolve repeated UPDATE failures in OceanBase by extracting information from Top SQL, log files, and the gv$sql_audit view, identifying error codes such as 6005, 6003, and 6212, and applying corrective actions like adjusting timeout settings, killing lock‑holding sessions, and checking lock statistics.
This article explains the different types of InnoDB row locks—including shared, exclusive, gap, next‑key, and insert‑intention locks—by showing preparation steps, SQL examples, lock‑mode details, and how they interact under repeatable‑read isolation in MySQL 8.0.32.
The article explains why using IN and NOT IN in SQL queries can lead to poor performance, index bypass, unexpected results with NULL values, and subtle bugs, and it recommends safer alternatives such as EXISTS, NOT EXISTS, and JOIN constructs.
This article presents a systematic benchmark comparing ClickHouse local (single‑node) tables and distributed tables across three data volumes—≈60 billion, 5 billion and 50 million rows—using a variety of aggregation and filter queries, and reveals that distributed tables dominate at large scale while the gap narrows as the dataset shrinks.
This article presents a detailed case study of refactoring a complex, performance‑critical SQL query used in a JDL routing system, demonstrating step‑by‑step formatting, hierarchical decomposition, and optimization techniques such as layer merging, predicate push‑down, join simplification, and index tuning to dramatically reduce execution time.
This article demonstrates how to refactor a complex, production‑level SQL query used in a routing system by formatting, decomposing into layers, merging temporary tables, pushing predicates, optimizing joins, and validating performance, ultimately reducing nesting from four levels to one and cutting execution time from 4.75 s to 0.6 s.
This article explains common scenarios of implicit type and charset conversions in MySQL, demonstrates how they cause index loss and performance degradation through detailed examples and EXPLAIN output, and provides practical guidelines to prevent such conversions in production environments.
This article provides an in‑depth tutorial on the sqlx package for Go, covering installation, type design, database connection methods, query execution, named parameters, transaction handling, prepared statements, unsafe scanning, field‑mapping customization, and practical code examples to simplify working with relational databases.
A quiet Saturday turned into a disaster when a simple UPDATE query accidentally deleted every order in production, prompting a rapid, step‑by‑step recovery, a post‑mortem analysis of the root causes, and a set of hard‑won operational lessons for any engineering team.
This article presents a comprehensive collection of MySQL performance guidelines, covering query writing, index usage, join strategies, data types, batch operations, and execution plan analysis to help developers write faster and more reliable SQL statements.
This article presents UCloud's USDP‑based streaming data lake warehouse solution that leverages Flink for real‑time processing and Paimon for lake storage, detailing its architecture, advantages, practical scenarios, and providing complete SQL and Flink CDC code snippets for end‑to‑end implementation.
This article explains how InnoDB full‑text search can replace LIKE% fuzzy queries by using inverted indexes, covering index structures, creation syntax, MATCH() AGAINST() modes, practical demos, query expansion, and index removal, while noting when to prefer external search engines.
This article presents a series of B2B testing scenarios—upload validation, rule retrieval, rule‑group matching, and similar rule conditions—demonstrating how targeted code review, precise test case design, and SQL verification can dramatically reduce test effort while uncovering hidden bugs.
This article explains MySQL's transaction concepts, the four isolation levels defined by the SQL standard, how each level prevents dirty reads, non‑repeatable reads, and phantom reads, and provides practical commands and example experiments to configure and observe their behavior in InnoDB.
This comprehensive guide explains MySQL transaction fundamentals, defines dirty reads, non‑repeatable reads and phantom reads, compares the four isolation levels, shows how to query and set them, and details the underlying locking mechanisms such as MVCC and next‑key locks.
Oracle announced its upcoming AI coding assistant, Code Assist, tailored for Java, Oracle Database, NetSuite scripts, and Oracle Cloud, offering chat-driven code suggestions, documentation generation, and security scanning across VS Code and JetBrains IDEs, while emphasizing multi‑language support and data privacy.
Donald Chamberlin, co‑author of SQL, explains why he now supports the NoSQL movement, describing how modern web applications demand scalability that traditional relational databases struggle to provide, and discusses emerging query languages like SQL++ (PartiQL) that bridge the gap between relational and document models.
This article explains how Lazada’s internal selection platform leveraged Hologres and the RoaringBitmap compression algorithm to dramatically reduce storage costs, accelerate set operations, and break the 200,000‑item pool limit, achieving up to a 99% speed improvement in scheduling.
This article explains how MySQL table‑level locks and metadata locks (MDL) can block both reads and writes, describes the two lock implementations, their types, the interaction with LOCK TABLES and FLUSH TABLES, and provides practical queries for diagnosing lock‑related blocking issues.
The OceanBase community offers a detailed, eight‑session DBA tutorial covering the platform’s architecture, deployment, migration, performance tuning, diagnostic tools, and ecosystem components, complemented by live streaming, hands‑on exercises, certification incentives, and real‑world user testimonials to help developers and DBAs master this distributed database.
Oracle’s latest release, Database 23ai, upgrades its 23c platform with AI-driven vector search, RAG capabilities, and enhanced JSON and graph querying, positioning the database as a unified, secure, and scalable solution for handling structured, semi‑structured, and unstructured data across cloud and on‑premises environments.
This article analyzes common anomalies caused by the PageHelper pagination plugin in a Java backend project—such as duplicate user registration, limited query results, and password‑reset errors—traces them to ThreadLocal misuse, explains the internal workflow of startPage, getLocalPage, and clearPage, and offers practical recommendations to avoid these pitfalls.
This article explains eight key reasons why SQL and relational database systems remain the dominant data management solution half a century after their invention, covering performance, maturity, community, simplicity, popularity, open‑source options, powerful query capabilities, and their continued relevance alongside newer technologies.
This article explains how to create a custom annotation and a MyBatis‑Plus interceptor that automatically injects data‑permission WHERE clauses into SQL statements, supports role‑based scopes, and shows both basic and advanced implementations with full Java code examples.
This guide explains how MySQL's InnoDB engine handles transactions and ACID properties, demonstrates exclusive and shared locking mechanisms, shows how to use connection pools, and provides reusable Python code for robust database operations, all illustrated with clear SQL and Python snippets.
This article outlines eight key reasons why SQL and relational databases remain the dominant data management solution half a century after their invention, covering processing power, proven reliability, community support, simplicity, widespread adoption, open‑source growth, practical query power, and their role alongside NoSQL technologies.
This article explains the purpose and inner workings of various database indexing algorithms—including B‑Tree, Hash, Bitmap, and Full‑Text indexes—illustrates their strengths and weaknesses with SQL examples, and provides guidance on when to choose each type for optimal query performance.
This article explains how to dramatically improve MySQL insert speed by adjusting database settings, choosing the MyISAM engine, and applying batch insertion methods such as concatenated SQL, transaction‑wrapped inserts, and MyBatis‑Flex saveBatch, complete with test code and performance results.
This article explains MySQL's architecture, how to view storage engines and variables, demonstrates creating various indexes, describes why SQL optimization is needed, details the EXPLAIN plan keywords and index types, and provides practical best‑practice tips for single‑ and multi‑table query performance improvements.
This guide compiles essential MySQL interview topics—including definitions, differences from Oracle and SQL Server, index types and usage, B‑tree vs B+‑tree structures, deadlock handling, and view concepts—providing a systematic overview for developers preparing for database interviews.
This article walks through the end‑to‑end lifecycle of a SQL task in a big‑data environment, covering creation, scheduling metadata, instance generation, resource allocation, ODPS execution, and final processing on the Fuxi distributed engine.
This article explains the concepts, formulas, and step‑by‑step implementation of a user‑retention analysis model, covering both Hive‑based offline processing and ClickHouse‑accelerated real‑time queries, complete with SQL examples, architecture diagrams, and practical optimization tips.
This article introduces Flyway as a database migration tool, explains its migration types and common commands, demonstrates how to integrate Flyway with Spring Boot using Maven and YAML configurations, provides example SQL migration scripts and logs, and briefly mentions related community promotions.
This guide explains the step‑by‑step SQL execution sequence, offers practical tips for optimizing multi‑table joins, and provides comprehensive indexing recommendations to improve query performance and reduce resource consumption.
This article introduces the Perfetto web UI, explains its four main sections, walks through essential navigation shortcuts, and shares practical techniques such as viewing wake‑up sources, critical paths, pinning threads, inspecting CPU info, buffer usage, timeouts, and logs to help Android developers efficiently analyze performance traces.
This article explains why using IN and NOT IN in SQL queries often leads to poor performance and incorrect results, and demonstrates safer alternatives such as EXISTS, NOT EXISTS, and JOINs with practical code examples.
This article demonstrates how the MySQL LIKE clause can give misleading results when filtering triggers, walks through a step‑by‑step lab that creates tables and triggers, shows the pitfalls of LIKE, and presents a safer WHERE‑based method for retrieving trigger definitions.
This article explains why using OFFSET and LIMIT for pagination becomes inefficient on large tables, illustrates the performance impact with examples, and proposes a cursor‑based pagination alternative that leverages indexed primary keys to achieve faster, scalable queries.
A Java developer recounts a production MySQL outage caused by a faulty batch insert, walks through failed delete and lock‑free attempts, then details a series of table‑recreation, truncate, and index‑rebuilding steps that finally restored data integrity and performance.
This article explains the logical execution order of SQL statements—including FROM‑JOIN, WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY and LIMIT—illustrates each step with examples and diagrams, and clarifies common misconceptions about clause sequencing.
This article explains how to boost MySQL insertion speed by adjusting server hardware, tuning database parameters, choosing the MyISAM engine, and especially applying three batch‑insert techniques—SQL concatenation, MyBatis‑Flex saveBatch, and manual transaction batching—while showing test results and configuration tips.
This article explains how an invisible zero‑width Unicode character embedded in a MySQL table name can make the table appear to disappear, demonstrates the problem with reproducible examples, analyzes the root cause, and provides practical steps to detect and fix such issues.
The article examines why MySQL LIMIT pagination becomes slower on deeper pages of a 500,000‑row table, analyzes query execution plans, and presents three optimization strategies—ordered index filtering, subquery pagination, and join‑based pagination—to improve performance in real‑world scenarios.
Learn how to assess and optimize your MySQL database using four powerful open‑source tools—mysqltuner.pl, tuning‑primer.sh, pt‑variable‑advisor, and pt‑query‑digest—complete with download links, command‑line usage examples, and guidance on interpreting their diagnostic reports to improve performance and security.
This article explains MaxCompute’s new integrated offline‑and‑near‑real‑time architecture, Transaction Table 2.0, detailing its unified storage and compute design, automatic data governance, schema evolution, upsert and time‑travel capabilities, and how it simplifies complex big‑data pipelines while delivering minute‑level latency and lower costs.
This article presents thirty practical SQL optimization techniques, ranging from avoiding SELECT * and using LIMIT 1 to proper indexing, join strategies, and query rewriting, each illustrated with code examples and clear explanations to help developers write faster, more efficient database queries.
This article explains MySQL events as built‑in schedulers, outlines their advantages, shows how to enable the event scheduler, create, view, modify, and drop events, and provides concrete examples for generating real‑time sales data and periodic statistics.
This article demonstrates how to mask sensitive data such as phone numbers, ID cards, and personal information using SQL string functions, a Java library (sensitive‑plus), and the MyBatis‑Mate Sensitive Jackson plugin, providing complete code examples, configuration files, and test results for backend developers.
This guide explains how to rescue both physically and logically deleted Oracle databases, covering RMAN file recovery, full database restoration, flashback table techniques, recycle‑bin usage, flashback database configuration, and essential backup strategies to prevent data loss.
MyScaleDB is a high‑performance, cost‑effective SQL vector database built on ClickHouse that lets developers use familiar SQL to store, index, and search billions of vectors alongside structured data, offering fast, accurate AI retrieval and seamless integration with existing tools.
This article explains MySQL InnoDB full-text search, covering inverted index structures, creation and usage of full-text indexes, query modes such as natural language, boolean, and query expansion, and provides practical SQL examples and considerations for effective text searching.
This article explains MySQL foreign keys, how to define them with CREATE TABLE syntax, cascade actions, limitations, pros and cons, and provides a complete MySQL 5.7 example with metadata queries and a cascade‑delete test, helping readers understand when to use or avoid foreign keys.
This article analyzes a slow NOT IN subquery that OceanBase rewrites into a NESTED‑LOOP ANTI JOIN, explains why HASH ANTI JOIN is not chosen due to NULL‑sensitive semantics and missing NOT NULL constraints, compares the behavior with Oracle's Null‑Aware Anti Join, and provides practical rewrite and hint‑based optimization recommendations.
This article explains the new mysqld-long-query-time option added to MySQL 8.0.30's mysqldump tool, shows how to configure it, presents comparative experiments demonstrating its effect on slow‑query logs, and provides conclusions and additional notes for practical database backup scenarios.
This article presents nine practical MySQL index optimization techniques—from selecting high‑selectivity columns and avoiding functions on indexed fields to applying the leftmost‑prefix rule, handling NULLs, using proper LIKE patterns, and leveraging EXPLAIN and LIMIT 1 for faster queries.
When a user reported errors, I discovered a MySQL table flooded with millions of bad rows from a new group, causing slow queries and crashes; I detail the step‑by‑step investigation, failed attempts with DELETE and lock‑free changes, and the final successful rebuild using temporary tables, DROP, TRUNCATE, and index reconstruction.
This article explains why using OFFSET with LIMIT becomes a performance bottleneck on massive tables, demonstrates the inefficiency of full‑table scans, and introduces a faster cursor‑based pagination technique that leverages indexed primary keys for efficient data retrieval.
This article walks through three real‑world MaxCompute optimization cases—tuning UNION handling, enabling JSON‑object batch extraction, and removing unnecessary GROUP BY—to dramatically reduce CPU, memory, and storage usage while improving job stability.
This article explains ten advanced SQL techniques—including common table expressions, recursive CTEs, temporary functions, CASE‑WHEN pivots, EXCEPT vs NOT IN, self‑joins, ranking functions, delta calculations, cumulative sums, and date‑time manipulation—providing clear explanations and complete query examples to help readers ace data‑science interview questions.
This tutorial walks through connecting to an SQLite database with PHP, creating a 'users' table using SQL, and verifying the table’s structure through PRAGMA queries, providing complete code examples for each step to help developers understand SQLite integration in web projects.
This article walks through the complete process of upgrading MySQL 5.7.43 to 8.0.34 on CentOS 7, covering lifecycle background, new 8.0 features, pre‑upgrade checks, data backup, configuration changes, installation, upgrade execution, post‑upgrade verification, and troubleshooting of typical SSL and host‑blocking issues.
This article explains how OFFSET and LIMIT cause severe performance problems on large tables due to full‑table scans, demonstrates the issue with real‑world examples, and presents a more efficient cursor‑based (keyset) pagination technique as a practical alternative.
This article explains a real‑world question about grouping 5,000 nationwide records by province to compute counts, totals, averages and ratios, compares using Excel pivot tables, SQL, and demonstrates a concise Python pandas pivot_table solution.
This article explains the MySQL 8.0.22 READ ONLY option for individual databases, demonstrates how to enable and verify the read‑only state with ALTER DATABASE and SHOW CREATE DATABASE commands, shows the impact on DDL/DML operations, lists usage restrictions, and notes exceptional cases and backup considerations.
Ctrip’s ticket business rebuilt its multi‑engine metrics platform by consolidating ClickHouse, Kylin, and Presto into a single StarRocks database, introducing temporary tables, materialized views, and streamlined ETL, which cut complex query times from minutes to seconds and doubled user traffic.
This guide walks you through installing the Go SQLite3 driver, opening a database connection, creating tables, inserting records, querying data, and provides a complete runnable example, helping developers integrate lightweight SQLite storage into Go applications efficiently.
This article provides a detailed tutorial on the PyMySQL library, covering installation, connection setup, cursor operations, executing queries, transaction handling, advanced features like batch processing and connection pooling, as well as best practices for error handling and performance optimization in Python‑MySQL applications.
The article reviews Flink 1.19’s new features, highlighting SQL capability enhancements such as custom source parallelism, TTL hints, and MiniBatch support for regular joins, as well as runtime dynamic parallelism for batch jobs and flexible checkpointing intervals for different data sources.
This guide walks you through creating a Spring Boot project, integrating the Druid connection‑pool, configuring its WebStatFilter and StatViewServlet for full SQL monitoring, testing the setup, and removing the built‑in advertisement via a custom filter.
This article enumerates the most frequent situations that cause MySQL indexes to become ineffective—such as violating the left‑most rule, using functions or expressions on indexed columns, type conversions, improper LIKE patterns, OR/IN/NOT IN usage, and inequality operators—and demonstrates how to reproduce and verify each case with sample data and SQL scripts.
The article introduces MySQL and PostgreSQL, compares their performance through a benchmark on identical hardware, discusses each system’s strengths, weaknesses, and suitable application scenarios, and provides guidance on choosing the appropriate database for different workloads.
The Apache Doris 2.1.0 release introduces over 100% query performance improvements on TPC‑DS, up to 230% gains on ARM platforms, new Variant and IP data types, async materialized views, auto‑increment columns, auto‑partitioning, group commit, hardened workload groups, TopSQL monitoring, a built‑in job scheduler, and several behavior changes, all aimed at delivering faster, more flexible and more reliable OLAP processing.
The article argues that focusing solely on benchmark speed misleads database choice, emphasizing that true performance must be measured by end‑to‑end user experience, ecosystem, maintainability, and future evolution rather than raw query latency alone.
This article explains why using IN and NOT IN in SQL can lead to poor performance and incorrect results, demonstrates common pitfalls with examples, and shows how to replace them with EXISTS, NOT EXISTS, or JOIN constructs for reliable and faster queries.
DBOS, a database‑driven cloud‑native operating system founded by Michael Stonebraker and Matei Zaharia, aims to replace traditional OS state management with SQL‑based databases, offering enhanced security, rapid ransomware recovery, and seamless integration with Kubernetes and Firecracker hypervisors.
This article explains why the SQL keywords IN and NOT IN often lead to poor performance and subtle bugs, demonstrates real‑world examples with large tables and NULL values, and recommends using EXISTS, NOT EXISTS, or JOINs as more reliable alternatives.
This article explains why slow SQL becomes a critical risk during large‑scale promotions, outlines a three‑step method—observing the query, analyzing it with EXPLAIN, and designing fixes—then demonstrates each step with concrete MySQL examples, tips, and overall optimization principles.
This guide explains why a remote PostgreSQL connection may fail with a password authentication error, analyzes common causes such as wrong credentials or misconfigured files, and provides step‑by‑step solutions including password reset, configuration checks, and trust authentication setup.
This article provides an in‑depth comparison of the open‑source SQL quality management platforms SQLE and Yearning, covering their architecture, supported data sources, UI design, SQL workbench capabilities, user management, ticket workflow, system settings, and overall suitability for different database environments.
This article explains how to construct effective SQL prompts by combining personal SQL expertise with large language model capabilities, introduces the open‑source sql‑translator tool for bidirectional SQL‑natural language conversion, and discusses practical productization scenarios.
The article explains the practical reasons for adding the always‑true condition “WHERE 1=1” in SQL, covering its role in preventing syntax errors, facilitating dynamic query building, copying tables, and its historical performance impact on MySQL.
This article explores SQLite’s 2018 SQL feature updates—from boolean literals and truth testing to window functions, FILTER clauses, upsert syntax, column renaming, and related API changes—highlighting syntax details, limitations, and practical examples for developers seeking to leverage these modern capabilities in production.
This guide walks you through using StarRocks—covering effortless expression‑based partitioning, streamlined data loading with INSERT FROM FILES and PIPE, powerful in‑flight data transformation using SELECT/JOIN/UNNEST, and flexible table structure tweaks via ALTER TABLE to boost query performance.
This article explains MySQL recursive queries using WITH RECURSIVE, detailing their structure, execution process, common use cases, and provides a step‑by‑step example with table creation, data insertion, and a paginated hierarchical query.
