The article compares several ways of inserting 300,000 MySQL rows—single‑row loops, an un‑batched MyBatis attempt that hits the max_allowed_packet limit, and a tuned batch strategy that commits every 1,000 rows—showing how the optimized batch reduces the runtime from hours to just 13 seconds and summarizing best‑practice tips.
This article analyzes how to import one billion 1 KB log records stored in HDFS or S3 into MySQL, detailing why a single table cannot hold that volume, the B‑tree index limits, batch‑write strategies, storage‑engine choices, sharding, file‑reading methods, task coordination, and reliability mechanisms.
The article catalogs six production‑ready pitfalls of MyBatis‑Plus—duplicate Snowflake IDs, batch‑insert disorder, enum storage errors, camel‑case mismatches, auto‑fill failures, and JSON field loss—explains their root causes with concrete examples and code, and provides practical solutions to keep the framework reliable in high‑concurrency environments.
This article analyzes ten frequent pitfalls when using MyBatis-Plus—such as incorrect pagination totals, pagination plugin misconfiguration, logical delete failures, auto‑fill issues, optimistic‑lock mismatches, null handling in QueryWrapper, batch‑insert performance, enum mapping errors, wrapper condition overrides, and type‑handler problems—provides root‑cause explanations, concrete code examples, and practical solutions to help developers write more robust and efficient Java backend code.
This article examines ten frequent pitfalls when using MyBatis-Plus—such as incorrect pagination counts, disabled pagination, logical‑delete mishandling, auto‑fill failures, optimistic‑lock issues, batch‑insert slowness, enum mapping errors, JSON type‑handler problems, and query‑wrapper quirks—explains their causes, and provides concrete code‑level solutions and best‑practice recommendations.
The article enumerates ten typical traps when using MyBatis-Plus—such as incorrect pagination counts, ineffective pagination plugins, logical delete mishandling, auto‑fill failures, optimistic‑lock issues, null‑value conditions, batch‑insert slowness, enum mapping errors, wrapper overwrites, and type‑handler problems—explains why they occur, and provides concrete code‑level solutions and best‑practice recommendations.
This article walks through a real‑world data‑migration case where 100,000 rows were moved from an old system to a new one, showing how naive per‑row inserts took five minutes and how a series of optimizations—batch SQL, JDBC batch mode, and multithreaded parallelism—reduced the runtime to just three seconds, while also covering common pitfalls and the final high‑performance implementation.
This article explains how to import 1 billion 1 KB log records stored in HDFS/S3 into MySQL by analyzing single‑table limits, proposing sharding into multiple tables, choosing the right storage engine, using batch inserts, controlling concurrency, and ensuring ordered, reliable processing with Redis and Redisson.
The article walks through three concrete optimizations—batch SQL, JDBC batch mode with rewriteBatchedStatements, and multithreaded parallel inserts—that shrink a 100,000‑row MyBatis insertion from five minutes to three seconds, while highlighting configuration details, performance gains, and common pitfalls.
The article walks through turning a naïve MyBatis loop that took five minutes to insert 100,000 rows into a high‑performance solution that finishes in three seconds by applying batch SQL, JDBC batch mode with rewriteBatchedStatements, and multithreaded parallel execution, while highlighting pitfalls and best‑practice configurations.
This article explains how to import a hundred‑million‑row Excel dataset into MySQL by using CSV format, streaming parsers like EasyExcel, batch inserts, asynchronous processing, and partial‑transaction strategies to ensure feasibility, data integrity, and high performance.
The article reviews the most common MyBatis‑Plus traps encountered in large‑scale Java services—duplicate Snowflake IDs, batch‑insert reordering, enum storage mismatches, camel‑case mapping errors, auto‑fill loss, and JSON field disappearance—explaining each root cause, illustrating it with real code snippets, and providing concrete solutions to keep production systems stable.
This article analyzes a MyBatis batch‑insert failure caused by the useGeneratedKeys setting after upgrading from 3.4.6 to 3.5.6, explains the root‑cause in the Jdbc3KeyGenerator, and provides both temporary and permanent solutions with code examples.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and JDBC, compares naïve single‑batch and per‑row approaches, presents optimized batch‑processing code with configurable batch sizes and wait times, and shares practical performance‑tuning tips such as index handling and connection‑pool configuration.
This article provides a comprehensive overview of Go's powerful GORM ORM library, covering its core concepts, architecture, internal logic, common pitfalls, practical tips, and advanced features such as soft deletes, transaction handling, batch operations, and integration with trpc-go, helping developers master GORM's inner workings.
This article analyzes why MyBatis foreach batch inserts become extremely slow with thousands of rows, explains the underlying parsing and PreparedStatement overhead, and presents faster alternatives such as ExecutorType.BATCH, Java‑side loops, and MyBatis Dynamic SQL batch support.
This article explains why using MyBatis foreach for bulk inserts can cause severe performance degradation, demonstrates the underlying parsing overhead, and shows how switching to ExecutorType.BATCH or limiting batch sizes to 20‑50 rows dramatically speeds up insert operations.
During massive daily imports of up to one million reconciliation records, MySQL deadlocks can cripple performance; this article dissects the four classic deadlock conditions, then presents a systematic “One‑Order Four‑Split” strategy—ordered writes, transaction splitting, index management, partitioning, and gap‑lock removal—backed by benchmarks, code samples, and configuration tweaks that cut lock rates by up to 90% and reduce batch times to under ten minutes.
This article explains why using MyBatis foreach for bulk inserts can cause severe performance degradation, analyzes the underlying parsing and executor issues, and provides practical solutions such as using ExecutorType.BATCH and limiting batch sizes to achieve fast, reliable batch insertion.
This article analyzes the poor performance of MyBatis‑Plus saveBatch, compares it with single inserts, manual SQL batching, and JDBC executeBatch, and shows how enabling the rewriteBatchedStatements flag can dramatically improve batch insert speed.
This article explains how to import 1 billion 1 KB log records stored in HDFS or S3 into MySQL by analyzing single‑table limits, using batch inserts, choosing storage engines, sharding, optimizing file‑reading methods, and coordinating distributed tasks with Redis, Redisson, and Zookeeper to ensure ordered, reliable, and high‑throughput data loading.
The article demonstrates advanced MyBatis‑Plus techniques—including high‑speed batch inserts with rewriteBatchedStatements, logical deletes via global config, automatic timestamp and user fields through MetaObjectHandler, JSON serialization with JacksonTypeHandler, dynamic table naming via an interceptor, and a brief multi‑tenant overview—to streamline development and reduce boilerplate code.
The article explains how inserts work in relational databases, why fixed‑size pages and batch transactions dramatically reduce I/O and lock contention, and provides practical MyBatis guidelines—using the foreach tag, ExecutorType.BATCH, and an appropriate batchSize while estimating memory and disk limits to choose an optimal batch size and commit only once.
The article investigates a MyBatis batch‑insert job that consumes excessive CPU and takes 14 minutes, explains why the foreach‑generated giant INSERT statement is inefficient, and demonstrates how switching to ExecutorType.BATCH or MyBatis dynamic‑SQL batch support reduces the runtime to under two seconds.
By configuring MySQL’s rewriteBatchedStatements=true, pre‑generating primary keys, adjusting MyBatis executor settings, and employing asynchronous multithreaded batch inserts, this guide demonstrates how to accelerate MyBatis‑Plus saveBatch operations from seconds to milliseconds, achieving up to a 2000% performance gain in large‑scale data scenarios.
This article explains how to dramatically improve MyBatis-Plus batch insertion speed—up to 2000%—by enabling rewriteBatchedStatements, pre‑generating primary keys to handle foreign‑key relationships, applying proper JDBC batch settings, and using asynchronous multithreaded insertion with optimized connection‑pool and executor configurations.
This article explains why a MySQL 8 InnoDB table with a unique index can still store duplicate rows—especially when indexed columns contain NULL or when logical deletion is used—and presents several practical strategies, including status counters, timestamps, extra IDs, hash fields, and batch‑insert techniques, to enforce true uniqueness.
This article explains why using MyBatis foreach for bulk inserts can cause severe performance degradation, analyzes the underlying cost of large prepared statements, and demonstrates how switching to ExecutorType.BATCH or limiting each INSERT to 20‑50 rows dramatically improves insertion speed.
This article explains how to dramatically speed up MyBatis-Plus batch inserts by enabling the rewriteBatchedStatements JDBC property, creating custom batch insert/update methods, and applying multithreading, providing code examples, performance test results, and practical recommendations for handling large data synchronizations.
This article presents a comprehensive engineering guide for importing one billion 1 KB unstructured log records stored in HDFS or S3 into MySQL, covering data sizing, B‑tree limits, batch insertion strategies, storage‑engine choices, sharding, file‑reading techniques, concurrency control, and reliable task coordination using Redis, Redisson, and Zookeeper.
This article explains why MyBatis-Plus's saveBatch() can be slow for large data sets, shows how enabling rewriteBatchedStatements in the JDBC URL dramatically speeds up inserts, and demonstrates custom batch insert/update methods and multithreaded execution to further improve performance, complete with code examples and test results.
This article explains how MySQL writes data to cache before flushing to disk, compares single‑row versus batch inserts, discusses how hardware limits, transaction size, and lock contention affect performance, and shows how to estimate an optimal batch size with concrete calculations and MyBatis examples.
To import one billion 1 KB log records stored in HDFS or S3 into MySQL efficiently, the article examines data partitioning, B‑tree index limits, batch insertion, storage engine choices, concurrency control, file‑reading methods, task scheduling with Redis, Redisson, and Zookeeper for reliable, ordered, high‑throughput loading.
This article demonstrates how to efficiently insert 300,000 rows into a MySQL table by using MyBatis batch operations, JDBC batch processing, and various performance optimizations such as batch size tuning, transaction management, and connection pooling.
This article demonstrates how to boost the insertion speed of over two million records by using Spring Boot with MyBatis‑Plus, a ThreadPoolTaskExecutor for multithreaded batch inserts, and detailed performance testing that shows a reduction from 5.75 minutes to 1.67 minutes.
This article demonstrates how to implement a high‑performance file upload system using Vue's Element Plus component on the frontend and Spring Boot on the backend, comparing single‑row inserts, batch inserts, and a multithreaded producer‑consumer approach to dramatically reduce MySQL insertion time.
This article analyzes how to import one billion 1 KB log records stored in HDFS or S3 into MySQL by evaluating single‑table limits, choosing storage engines, designing sharding, batch insertion, file‑reading strategies, task coordination, and distributed locking to achieve high‑throughput and ordered writes.
This article evaluates MySQL single‑thread write performance by testing three insertion methods—continuous while‑loop inserts, JDBC batch processing, and multi‑row INSERT statements—detailing setup, code examples, and measured rows per minute to reveal their relative throughput and stability.
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 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.
The article walks through a performance test of inserting over 100,000 rows with many columns, showing how a naïve loop takes about 80 seconds while JDBC batch, manual transaction control, and MyBatis/MyBatis‑Plus batch APIs can reduce the time to roughly one second.
This article analyzes how to import one billion 1 KB log records stored in HDFS or S3 into MySQL efficiently, covering constraints, single‑table limits, batch insertion, storage‑engine choices, sharding, file‑reading techniques, task reliability, and concurrency control to achieve optimal throughput.
The article shows how to efficiently load 300,000 MySQL rows in Java by comparing MyBatis and plain-JDBC batch inserts, demonstrating that batching 1,000‑5,000 records per transaction with proper transaction control, connection pooling, and MySQL tuning reduces insertion time from hours to seconds.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and JDBC, compares bulk batch insertion with per‑row looping, discusses packet size limits, transaction handling, performance metrics, and provides practical code snippets and optimization tips for efficient large‑scale data loading.
This guide explains how to efficiently load one billion 1‑KB log entries from HDFS or S3 into MySQL by analyzing B‑tree limits, using batch inserts, choosing the right storage engine, sharding tables, optimizing file reading, and coordinating tasks with Redis, Redisson, and Zookeeper.
Understanding MySQL’s auto‑increment mechanism reveals why IDs can become non‑sequential due to storage differences, transaction rollbacks, unique key conflicts, and batch inserts, and shows how lock‑mode settings and MySQL 8.0 improvements can optimize performance and maintain consistency.
This article demonstrates how to boost the insertion speed of over two million records by configuring a Spring Boot ThreadPoolTaskExecutor, integrating it with MyBatis‑Plus and PostgreSQL, and measuring multi‑threaded versus single‑threaded performance to determine the optimal thread count.
This article details how to dramatically speed up the import of massive Excel files (over 100,000 rows) into a Java backend by switching to EasyExcel, caching database lookups, using batch VALUES inserts, and parallelizing the write operations with functional utilities.
To achieve fast bulk inserts in MyBatis, open a session with ExecutorType.BATCH and insert records individually (letting JDBC batch them), limit foreach‑generated statements to about 20‑50 rows, or use MyBatis dynamic‑SQL or plain JDBC batch, avoiding massive SQL parsing and CPU overload.
This article explains why MyBatis-Plus saveBatch does not perform true batch inserts, shows how to enable JDBC rewriteBatchedStatements, creates a custom SQL injector with InsertBatchSomeColumn, implements batch splitting in a service layer, and presents benchmark results that demonstrate a several‑second speedup for inserting tens of thousands of rows.
This article outlines a comprehensive strategy for rapidly loading one billion 1 KB log records stored in HDFS or S3 into MySQL, covering data partitioning, B‑tree limits, batch inserts, storage‑engine selection, sharding, concurrent write control, efficient file reading, task coordination, fault‑tolerant progress tracking with Redis, and distributed locking with Redisson.
This article walks through the full engineering process of importing a billion 1 KB log records into MySQL, covering data size calculations, B‑tree index limits, batch‑insert strategies, storage‑engine trade‑offs, fast file‑reading techniques, task coordination with Redis and Redisson, and distributed‑lock design using Zookeeper.
To import one billion 1 KB log records into MySQL efficiently, the article examines data size constraints, B‑tree index limits, batch insertion strategies, storage engine choices, file‑reading techniques, task coordination with Redis, Redisson semaphores, and distributed lock handling to ensure ordered, reliable, high‑throughput loading.
This article explains why using MyBatis‑Plus saveBatch for bulk inserts can cause 5‑6 second delays, analyzes the underlying per‑row INSERT behavior, and shows how adding rewriteBatchedStatements=true to the JDBC URL dramatically reduces execution time to a few hundred milliseconds.
This tutorial walks through MyBatis-Plus's advanced capabilities—including high‑performance batch inserts, logical deletion with global config, automatic timestamp and user fields via MetaObjectHandler, JSON type handling, dynamic table name resolution, and multi‑tenant support—showing concrete code, configuration, and benchmark results for each feature.
This article analyzes the constraints of loading one billion 1 KB log records from distributed storage into MySQL, evaluates single‑table limits, proposes batch‑insert, sharding, storage‑engine, file‑reading, and distributed‑task coordination techniques to achieve high‑speed, ordered, and reliable data ingestion.
This article explains how to import 1 billion 1 KB log records stored in HDFS or S3 into MySQL by analyzing table capacity limits, choosing storage engines, designing batch inserts, coordinating file reading and writing, and handling task reliability with Redis, Redisson, and Zookeeper.
This article demonstrates multiple approaches—including direct MyBatis batch, per‑row insertion, and JDBC batch processing—to insert 300,000 user records into a MySQL table, compares their performance, and provides practical optimization tips such as batch size tuning, waiting intervals, index handling, and connection‑pool configuration.
This article demonstrates multiple ways to insert 300,000 rows into a MySQL table using MyBatis and JDBC, compares batch, loop, and single‑record approaches, analyzes execution time and resource usage, and provides practical optimization tips for high‑throughput data loading.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and plain JDBC, compares direct batch insertion, per‑row insertion, and staged batch processing, and provides practical performance tips such as batch size, waiting intervals, index handling, and connection‑pool configuration.
This article demonstrates multiple approaches—including MyBatis batch inserts, per‑row inserts, and JDBC batch processing—to efficiently load 300,000 user records into a MySQL table, compares their performance, and provides practical optimization tips such as batch size, waiting intervals, and index handling.
When interviewers ask how to insert a thousand rows with MyBatis, the answer isn’t just a simple Java for‑loop; you need to consider batch processing, disable autocommit, and understand MyBatis’s limits to choose the most reliable and performant approach.
This article details a step‑by‑step optimization of a high‑volume Excel import workflow in Java, covering the migration from raw POI to EasyPOI and EasyExcel, caching database lookups, using MySQL batch inserts, and leveraging parallel streams to reduce import time from minutes to under two minutes.
This article demonstrates multiple strategies for inserting 300,000 rows into a MySQL table using MyBatis and JDBC, comparing batch‑insert, single‑row loops, packet size limits, transaction handling, and performance tuning techniques such as batch size, waiting intervals, and index management.
This article demonstrates how to boost the insertion speed of over two million records by configuring Spring Boot's ThreadPoolTaskExecutor for multithreaded batch inserts, detailing the setup, code implementation, performance testing, and analysis of results.
The article explains three ways to perform batch inserts with MyBatis—ordinary single-row inserts, foreach‑based bulk inserts, and ExecutorType.BATCH—analyzes their SQL logs, performance bottlenecks, MySQL limits, and provides practical recommendations for large‑scale data insertion.
This article explains why MyBatis foreach‑based batch inserts become extremely slow with thousands of rows, demonstrates how the generated giant SQL statement hurts performance, and shows how switching to ExecutorType.BATCH or limiting rows per INSERT dramatically reduces insertion time.
This article explains why MyBatis foreach‑based batch inserts become extremely slow with thousands of rows, analyzes the underlying SQL generation and parsing costs, and demonstrates how using ExecutorType.BATCH or limiting rows per INSERT can reduce a 14‑minute operation to under two seconds.
This article analyzes why MyBatis‑Plus's default saveBatch method does not achieve true batch insertion, explains how to enable JDBC batch mode with rewriteBatchedStatements, and demonstrates creating a custom SQL injector (InsertBatchSomeColumn) to perform real batch inserts, including performance test results showing significant speed improvements.
This article presents five common batch‑insert approaches for MyBatis and MyBatis‑Plus—including a for‑loop, manual batch commit, collection‑based batch, saveBatch, and InsertBatchSomeColumn—provides complete code examples, configuration steps, and measured execution times to help Java backend developers choose the most efficient method.
This article presents a detailed overview of five commonly used MyBatis and MyBatis-Plus batch insertion methods, including code examples, configuration steps, and performance measurements for inserting ten thousand records, helping developers choose the most efficient approach for large‑scale data insertion in Java backend projects.
This article presents and compares five practical batch‑insert methods for MyBatis and MyBatis‑Plus, covering preparation steps, code implementations, configuration details, and performance results, helping developers choose the most efficient approach for inserting large volumes of data in Java backend projects.
This article evaluates the efficiency of inserting massive synthetic person data into MySQL using Java, comparing MyBatis, plain JDBC (with and without transactions), and JDBC batch processing, and presents detailed timing results for each strategy across tens of millions of rows.
An in‑depth guide explains why using MyBatis’s foreach for bulk inserts can cause severe performance degradation, especially with large tables, and demonstrates how switching to ExecutorType.BATCH or limiting batch sizes to 20‑50 rows dramatically reduces insertion time from minutes to seconds.
The article explains why MyBatis batch inserts using a foreach-generated single INSERT statement can cause severe CPU and latency issues, and demonstrates how to achieve fast bulk insertion by limiting batch size or switching to ExecutorType.BATCH with code examples.
The article explains why MyBatis foreach‑based batch inserts can cause extreme CPU usage and long execution times, demonstrates how combining multiple VALUES into a single INSERT or using ExecutorType.BATCH dramatically improves performance, and provides practical code examples and sizing recommendations.
This article investigates how many rows should be inserted per batch in MySQL by measuring the impact of packet size limits, buffer pool usage, insert buffers, transaction handling and index structures, and it provides practical recommendations based on tests with millions of rows.
This article analyzes MySQL batch insertion by examining field size, max_allowed_packet limits, transaction overhead, buffer pool usage, and empirical tests with varying batch sizes, ultimately recommending a batch size around half of the max_allowed_packet for optimal throughput.
This article walks through optimizing a slow MySQL batch import by first inserting a list directly, then using grouped inserts, and finally applying multithreaded batch processing with MyBatis, showing code examples and practical tips to reduce import time from over a minute to under ten seconds.
This article walks through generating a 10‑million‑row MySQL table, inserting data with a fast batch script, measuring plain LIMIT pagination performance, and applying several optimization techniques—including sub‑queries, ID‑range filtering, and column selection—to dramatically reduce query time on large data sets.
This article analyzes why MyBatis foreach‑based batch inserts become extremely slow with thousands of rows, explains the underlying SQL and PreparedStatement overhead, and demonstrates how switching to ExecutorType.BATCH or limiting foreach values to 20‑50 rows dramatically improves MySQL insertion performance.
This article explains why MyBatis batch inserts using a foreach loop can become extremely slow when inserting thousands of rows, analyzes the underlying cost of parsing large prepared statements, and presents practical solutions such as using ExecutorType.BATCH, limiting foreach batch size, and employing JDBC batch execution to achieve sub‑second performance.
This article explains why MyBatis foreach batch inserts can become extremely slow when inserting thousands of rows, analyzes the underlying SQL and PreparedStatement overhead, and demonstrates how using ExecutorType.BATCH together with a limited batch size (20‑50 rows per statement) dramatically improves insertion speed.
This article explains how MyBatis native batch inserts can exceed MySQL's maximum SQL size, causing errors, and demonstrates a solution using Guava's Lists.partition to split the data into smaller chunks, improving performance and avoiding execution failures.
This article introduces three MyBatis batch insertion techniques—looped single inserts, MyBatis‑Plus batch inserts, and native SQL batch inserts—provides complete implementation code, performance test results for inserting 100,000 records, analyzes the causes of differences, and offers practical solutions to common pitfalls such as MySQL packet size limits.
This article demonstrates three progressive techniques—direct list insertion, grouped batch insertion, and multithreaded batch insertion—using MyBatis to dramatically reduce MySQL bulk‑import time from over a minute to under ten seconds while handling packet size limits.
This article explains how to improve database insertion performance in Java by replacing per‑iteration inserts with MyBatis‑Plus’s saveBatch method, detailing dependency setup, schema creation, entity, controller, service, and mapper code for efficient bulk operations.
This guide demonstrates how to set up Spring Boot 2.3.12 with Elasticsearch 7.8, configure separate JPA and Elasticsearch repositories, and implement two batch insertion methods—using ElasticsearchRestTemplate and repository saveAll—while measuring performance, showing comparable execution times for inserting 10,000 records.
The article evaluates three data‑insertion techniques—repeated single inserts, XML‑based SQL concatenation, and batch processing—within a SpringBoot application using SQL Server, presenting code examples, test results, and recommendations on when to use each method.
This article explains several MySQL techniques—INSERT IGNORE, ON DUPLICATE KEY UPDATE, INSERT…SELECT WHERE NOT EXISTS, and REPLACE—plus a practical MyBatis batch‑insert example, to handle large‑scale data imports while preventing duplicate records.
This article demonstrates how to dramatically speed up importing tens of thousands of records into MySQL by evolving a naïve list‑to‑MySQL approach into grouped batch inserts and finally a multi‑threaded MyBatis solution, while also addressing packet size limits and configuration tweaks.
This article details how to dramatically speed up the import of massive Excel fee‑record files in a Java backend by switching to EasyExcel, caching database lookups, using batch INSERT statements, and applying parallel streams while eliminating excessive logging.
This article evaluates three ways to insert records into a SQL Server database—repeated single inserts, XML‑concatenated SQL, and batch processing—under SpringBoot, presents performance tests, and recommends the most suitable approach based on data volume and code simplicity.
The article discusses efficient ways to perform bulk inserts in MySQL while avoiding duplicate records, covering techniques such as INSERT IGNORE, ON DUPLICATE KEY UPDATE, INSERT…SELECT…WHERE NOT EXISTS, REPLACE INTO, and demonstrates a practical MyBatis implementation with a unique mobile_number constraint.
This article details a step‑by‑step optimization of a Java backend Excel import pipeline, covering requirement analysis, performance bottlenecks, caching strategies, batch insertion techniques, parallel processing, and practical code examples to reduce a 10‑minute import to under two minutes.
This article explains why multithreaded inserts into MySQL can outperform single‑threaded writes, breaks down the time spent on connection, parsing and insertion, and presents practical techniques such as prepared statements, batch processing, multi‑value inserts, and transaction batching that together can reduce insert time to seconds for massive data sets.
This article evaluates three ways to insert records into a SQL Server database—repeated single inserts, XML‑based SQL concatenation, and batch processing—under a Spring Boot environment, providing code examples, performance test results, and practical recommendations for different data volumes.
This article describes how to dramatically speed up the import of massive Excel files in a Java backend by replacing raw POI with EasyExcel, caching database lookups, using MySQL batch inserts, and employing parallel streams to achieve sub‑minute processing for hundreds of thousands of rows.
This article details how to dramatically speed up the import of massive Excel files in a Java backend by switching to EasyExcel, caching database lookups, using batch inserts, and applying parallel streams while eliminating excessive logging.
This article explains how to enhance MyBatis-Plus by adding Maven dependencies, creating custom injector and mapper interfaces, and implementing a true batch‑insert method for MySQL, enabling developers to persist collections of entities efficiently in a Spring Boot backend.
