Tagged articles
DELETE
53 articles · Page 1 of 1

liandkAug 16, 2026 · Databases
This article clarifies the difference between SQL DELETE and DROP TABLE, showing that DELETE removes rows while preserving table structure (and requires a WHERE clause), whereas DROP TABLE eliminates the entire table, and provides practical scenarios and code examples for each.
DELETEDROP TABLEData Manipulation
0 likes · 2 min read

The SLS LogStore team explains why they introduced native update and delete capabilities to the traditionally append‑only log service, detailing the design trade‑offs, the enableModify flag, row‑level addressing, API usage, practical scenarios such as billing corrections, risk label refreshes, LLM feedback, and operational edits, and the limits of the new feature.
Cloud LoggingDELETELogStore
0 likes · 14 min read

The article explains MySQL's storage architecture, compares DELETE, TRUNCATE and DROP for removing data, shows how DELETE leaves hidden rows and generates logs that waste space, and advises using TRUNCATE, DROP or OPTIMIZE TABLE to reclaim disk space and avoid irreversible mistakes.
DELETEDROPData Storage
0 likes · 8 min read

The article examines a Go TODO app where moving a task required a Delete‑then‑Insert pattern, highlights the inefficiency of two memory moves, introduces the slices.Move proposal that performs a single copy, reviews community arguments, and makes a case for adding Move to the standard library.
DELETEGoINSERT
0 likes · 11 min read

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.
DELETEDROPInterview
0 likes · 9 min read

This article explains C++ memory management fundamentals, detailing how delete and free release memory without explicit size knowledge, the role of stack, heap, data and code segments, differences between new/delete and malloc/free, array handling, common pitfalls, and interview questions with code examples.
C++DELETEHeap
0 likes · 34 min read

The article explains why using DELETE to remove rows in MySQL is discouraged, covering storage architecture, engine behavior, transaction handling, space reclamation, and compares DELETE with TRUNCATE and DROP in terms of speed, safety, and side effects.
DELETEDROPMySQL
0 likes · 10 min read

This article explains MySQL's storage architecture, why using DELETE to remove rows is discouraged, compares DELETE, DROP, and TRUNCATE in terms of speed, space reclamation, transaction behavior, and auto‑increment handling, and provides practical commands and optimization tips.
DELETEDROPData Storage
0 likes · 9 min read

This article explains MySQL's storage architecture, compares the DELETE, TRUNCATE, and DROP commands, shows their performance and side‑effects, and provides practical guidance on choosing the safest and most efficient way to remove data from a MySQL table.
DELETEDROPDatabase Storage
0 likes · 9 min read

This article introduces the binary search tree (BST) data structure, explains its core concepts, provides Python implementations for node definition, search, insert, and delete operations, compares performance, and discusses practical applications and exercises.
AlgorithmsBSTDELETE
0 likes · 7 min read

This article examines a puzzling MySQL deadlock where two identical DELETE statements on a uniquely indexed table block each other, explains the underlying lock mechanisms, reproduces the issue with SQL and Java code, and offers practical mitigation strategies.
DELETEMySQLUnique Index
0 likes · 13 min read

This article analyzes why two identical DELETE statements on a MySQL table with a unique index can deadlock, explains InnoDB lock types, walks through the execution flow, reproduces the issue with SQL and Java code, and discusses mitigation strategies.
ConcurrencyDELETEInnoDB
0 likes · 15 min read


ITPUBJul 4, 2024 · Databases
This article explains how two identical DELETE statements on a table with a unique index can cause a deadlock in MySQL 5.7, reviews InnoDB lock types, reproduces the issue with SQL and Java code, and discusses mitigation strategies and behavior changes in MySQL 8.
DELETEInnoDBMySQL
0 likes · 14 min read

This article examines why identical DELETE statements on a MySQL table with a unique index can cause deadlocks, reviews InnoDB lock types, reproduces the issue with SQL and Java code, and discusses mitigation strategies such as version upgrades, isolation level changes, and distributed locks.
DELETEInnoDBMySQL
0 likes · 14 min read

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.
DELETEMySQLSQL
0 likes · 5 min read

This article explains what constitutes a Redis BigKey, why oversized keys degrade performance through data skew, network blocking, slow queries and CPU pressure, and provides practical detection methods, open‑source tooling, and mitigation techniques such as lazy‑free deletion, incremental scans, and key sharding.
BigKeyDELETERedis
0 likes · 21 min read

This article explains the three primary ways to delete data in MySQL—using DELETE, TRUNCATE, and DROP—detailing their execution speed, underlying mechanisms, storage‑engine differences, and best‑practice considerations such as space reclamation and auto‑increment handling.
DELETEDROPMySQL
0 likes · 5 min read

The article explains a puzzling MySQL DELETE failure caused by a missing primary key, shows how Navicat adds an ESCAPE clause to the generated SQL, clarifies the purpose of ESCAPE in LIKE patterns, and reveals that the real issue was a mistaken condition order in the query.
DELETEDebuggingMySQL
0 likes · 4 min read

The article explains why adding a LIMIT clause to MySQL DELETE statements is a recommended habit, detailing performance gains, reduced locking, safer error handling, and practical execution strategies for large‑scale deletions.
DELETELIMITMySQL
0 likes · 6 min read

This article explains the behavior of NaN values in Go maps, demonstrates a related IEEE‑754 quiz, and discusses the ongoing proposal to introduce a delete(m) function that can reliably clear maps even when they contain NaN keys.
BackendDELETEGo
0 likes · 6 min read

This article examines ClickHouse’s lack of native upsert and delete operations, explains how ByteHouse’s UniqueMergeTree engine introduces a Mark‑Delete + Insert approach to provide real‑time upsert/delete capabilities, and presents benchmark results showing dramatically faster queries with only modest write overhead.
ByteHouseClickHouseColumnar Database
0 likes · 10 min read

This guide explains how to identify duplicate rows in a MySQL table using GROUP BY and HAVING, how to delete the extra rows while keeping the earliest entry, and how to handle duplicate detection across multiple columns with correct query patterns and common pitfalls.
DELETEHAVINGMySQL
0 likes · 11 min read

The article explains the three primary MySQL data removal commands—DELETE, TRUNCATE, and DROP—detailing their execution speed, underlying mechanisms, impact on disk space for InnoDB and MyISAM engines, and best‑practice usage such as running OPTIMIZE TABLE after DELETE.
DELETEDROPInnoDB
0 likes · 7 min read

When trying to change a table’s primary key from int to bigint, a 500‑million‑row MySQL table required data archiving and a bulk MODIFY, but parallel DELETE statements caused lock‑wait timeouts; experiments reveal that under REPEATABLE READ the range scan locks the boundary row, leading to contention.
DELETELarge TablesLock
0 likes · 11 min read

This article walks through using the FunTester framework to benchmark MySQL insert and delete operations, showing Java code examples, test configurations, and JSON results that reveal a high QPS for inserts and a noticeable slowdown when deletions are performed.
BenchmarkDELETEFunTester
0 likes · 7 min read

This article explains why deleting rows in MySQL does not shrink the underlying table file, describes the InnoDB storage mechanics that cause this behavior, and provides practical solutions such as OPTIMIZE TABLE, ALTER TABLE, and Online DDL to reclaim space and avoid table‑locking issues.
ALTER TABLEDELETEInnoDB
0 likes · 8 min read

Learn the essential MySQL Data Manipulation Language commands—INSERT, UPDATE, DELETE, and TRUNCATE—including syntax variations, best practices, and step‑by‑step command‑line examples that illustrate single‑row, batch, and conditional operations, plus key differences between delete and truncate.
DELETEDMLINSERT
0 likes · 12 min read

The article explains why MySQL’s DELETE command does not shrink the physical table file, describes InnoDB’s storage mechanics, and shows how to reclaim space using OPTIMIZE TABLE, ALTER TABLE, and Online DDL options.
ALTER TABLEDELETEDatabase Maintenance
0 likes · 7 min read

This article investigates why a DELETE IN subquery in MySQL 5.7 performs a full table scan instead of using an index, explains the optimizer’s behavior compared to SELECT IN, and provides practical solutions such as rewriting the statement as a JOIN or adding table aliases to enable index usage.
DELETEMySQLSQL Optimization
0 likes · 6 min read

This article explains why MySQL's DELETE command only marks rows as reusable without shrinking the .ibd file, describes the underlying B+‑tree storage mechanism, and provides practical solutions such as OPTIMIZE TABLE, ALTER TABLE, and online DDL options to reclaim space and avoid table‑level locks.
DELETEInnoDBonline DDL
0 likes · 7 min read

This guide explains step‑by‑step how to identify and delete duplicate records in MySQL tables, covering simple SELECT checks, handling MySQL’s update‑from limitation, and fast deletion techniques that keep one record per duplicate group.
DELETEMySQLSQL
0 likes · 5 min read

The article explains why deleting rows in MySQL does not shrink the physical table file, describes the underlying InnoDB storage mechanisms, and provides practical methods such as OPTIMIZE TABLE, ALTER TABLE, and Online DDL to reclaim space and reorganize the table.
ALTER TABLEDELETEDatabase Maintenance
0 likes · 7 min read

This article experimentally demonstrates how increasing the number of secondary indexes on MySQL tables progressively degrades write operations—including INSERT, UPDATE, DELETE, and LOAD DATA—by measuring execution times across ten tables with one to ten indexes each.
DELETEINSERTLOAD DATA
0 likes · 14 min read

This tutorial walks through MySQL join techniques—including WHERE, LEFT, and INNER joins—shows how to retrieve specific columns, and provides clear examples of inserting single or multiple rows, updating records, and deleting data, all illustrated with step‑by‑step SQL code and result screenshots.
DELETEINSERTMySQL
0 likes · 7 min read

This article walks through a practical MySQL tutorial that identifies duplicate records, explains why naïve row‑by‑row deletion is slow, and provides efficient DELETE statements—including derived‑table tricks—to clean up large tables while preserving one record per duplicate group.
DELETEMySQLSQL
0 likes · 6 min read

The article explains why deleting rows in MySQL does not shrink the .ibd file because InnoDB only marks pages as reusable, and shows how to reclaim space using OPTIMIZE TABLE, ALTER TABLE, and Online DDL options.
ALTER TABLEDELETEDatabase Maintenance
0 likes · 7 min read

This article explains the evolution from traditional data warehouses to modern lakehouse architectures, introduces the Arctic system’s dynamic hash tree for fast update/delete, describes file splitting with sequence/offset ordering, and compares copy‑on‑write versus merge‑on‑read techniques for achieving low‑latency analytics.
ArcticDELETEData Update
0 likes · 12 min read

This article explains why deleting rows in MySQL does not decrease the physical table file size, describes the underlying InnoDB storage mechanisms, and shows how to reclaim space using OPTIMIZE TABLE, ALTER TABLE, and Online DDL options.
ALTER TABLEDELETEInnoDB
0 likes · 7 min read

The article explains why appending LIMIT to MySQL DELETE statements improves performance, reduces lock contention, and safeguards data by limiting rows affected, provides syntax details, compares deletion strategies for removing large numbers of rows, and offers practical recommendations for safe and efficient data removal.
DELETEData SafetyDatabase Performance
0 likes · 8 min read

This article explains how to identify duplicate rows in a MySQL table using GROUP BY and HAVING, shows several SELECT queries to list duplicates, and provides multiple DELETE strategies—including sub‑queries and multi‑column handling—to safely remove excess records while keeping one copy.
DELETEMySQLSQL
0 likes · 9 min read

This article compares MySQL's three data‑removal commands—DELETE, TRUNCATE, and DROP—detailing their execution speed, underlying mechanisms, impact on disk space and auto‑increment values, and best‑practice usage with code examples and optimization tips.
DELETEDROPMySQL
0 likes · 7 min read

The article explains that using LIMIT with DELETE in MySQL improves safety, reduces lock time, prevents long‑running transactions, and enhances performance, and it provides syntax, examples, and expert opinions to illustrate the benefits of this habit.
DELETEDatabase PerformanceLIMIT
0 likes · 7 min read

This article explains why adding a LIMIT clause to MySQL DELETE statements is a good habit, compares it with TRUNCATE, shows the correct syntax, outlines performance and safety advantages, and discusses practical strategies for deleting large numbers of rows.
DELETELIMITMySQL
0 likes · 7 min read

This article explains the three primary ways to remove data in MySQL—DELETE, TRUNCATE, and DROP—comparing their execution speed, underlying mechanisms, impact on disk space, transaction behavior, and how to reclaim space with OPTIMIZE, while providing practical SQL examples and usage warnings.
DELETEDROPMySQL
0 likes · 6 min read

This article explains why appending a LIMIT clause to MySQL DELETE statements improves safety, reduces lock time, and boosts performance, while comparing three deletion strategies and recommending the most efficient approach for large‑scale data removal.
DELETELIMITMySQL
0 likes · 8 min read

This article details a two‑month journey of reading MySQL 8.0.20 source code to uncover how the DELETE statement performs mark‑delete, describing the experimental setup, trace‑log analysis, query and delete phases, and the exact functions that set the deletion flag in InnoDB.
DELETEDebuggingInnoDB
0 likes · 19 min read

This article explains why a DELETE statement with a sub‑query can cause a full‑table scan in MySQL, describes the optimizer's semijoin, materialization and exists strategies for different sub‑query types, and shows how to rewrite the statement using a JOIN for better performance.
DELETEMySQLjoin
0 likes · 9 min read

This article explains how MySQL's InnoDB engine marks rows as deleted without freeing disk space, demonstrates the issue with 100,000 rows, and shows how the OPTIMIZE TABLE or ALTER TABLE commands can rebuild the table to reclaim space and improve performance.
DELETEDatabase PerformanceInnoDB
0 likes · 7 min read

This guide explains how to define duplicate rows, use GROUP BY and HAVING to locate them, and apply temporary tables and DELETE statements to remove duplicates while preserving the row with the smallest ID.
DELETEHAVINGSQL
0 likes · 11 min read

This article shows step‑by‑step how to identify duplicate rows in a MySQL table—whether the duplication is based on a single column, multiple columns, or either column—and provides reliable SQL patterns, including GROUP BY with HAVING, UNION, sub‑queries, temporary tables, and a safe DELETE statement to clean the data.
DELETEHAVINGMySQL
0 likes · 11 min read


ITPUBDec 14, 2018 · Databases
This article explains how to select the right index for mixed‑type queries, quantitatively compare query performance with and without LIMIT, and safely handle long‑running DELETE statements by using InnoDB status and proper kill techniques.
DELETEInnoDBSQL
0 likes · 4 min read

This article walks through the fundamentals of SQL Server, covering installation, core SQL concepts, DML and DDL commands, and detailed examples of SELECT, INSERT, UPDATE, and DELETE statements with accompanying syntax illustrations to help beginners master relational database operations.
DELETEDatabase TutorialINSERT INTO
0 likes · 7 min read


ITPUBJun 14, 2016 · Databases
This guide explains how to locate rows with identical values across one or several columns using self‑joins, GROUP BY, DISTINCT, and rowid, and provides step‑by‑step SQL statements to safely delete the extra duplicate entries from a table.
DELETEDISTINCTSQL
0 likes · 7 min read
