BestHub
Sign in
Tagged articles
311 articles
Page 3 of 4
Code DAO
Code DAO
Jan 18, 2022 · Backend Development

Implementing Pagination, Filters, and Error Handling in a Go Clean Architecture with Ent and gqlgen (Part 3)

This tutorial walks through adding pagination and flexible where‑filters to the User List interface, configuring gqlgen extensions, handling GraphQL errors, wrapping mutations in transactions, and building unit, integration, and end‑to‑end tests for a Go clean‑architecture project using Ent and gqlgen.

Clean ArchitectureError HandlingGo
0 likes · 23 min read
Implementing Pagination, Filters, and Error Handling in a Go Clean Architecture with Ent and gqlgen (Part 3)
Python Crawling & Data Mining
Python Crawling & Data Mining
Jan 16, 2022 · Fundamentals

Master Web Scraping with Chrome’s Web Scraper: Install, Sitemap & Advanced Pagination

This guide walks you through installing the Chrome Web Scraper extension, explains core concepts like sitemaps and selectors, and demonstrates how to handle both simple and complex pagination as well as secondary page crawling, enabling you to extract structured data from websites without writing code.

Chrome ExtensionSitemappagination
0 likes · 9 min read
Master Web Scraping with Chrome’s Web Scraper: Install, Sitemap & Advanced Pagination
Code DAO
Code DAO
Jan 15, 2022 · Backend Development

Implementing Clean Architecture with ent and gqlgen – Part 2

This article walks through integrating the four Clean Architecture layers—entity, use‑case, interface‑adapter, and framework/driver—into a Go application using ent for ORM and gqlgen for GraphQL, covering folder layout, ULID primary keys, Node interface support, and pagination implementation.

Clean ArchitectureGoGraphQL
0 likes · 19 min read
Implementing Clean Architecture with ent and gqlgen – Part 2
Java Backend Technology
Java Backend Technology
Jan 15, 2022 · Databases

Why Large OFFSETs Slow MySQL Queries and How Subquery Optimization Fixes It

The article explains how using a large OFFSET in MySQL pagination forces the server to read and discard many rows, causing severe performance degradation, and demonstrates that rewriting the query to first fetch primary‑key IDs via a subquery dramatically reduces I/O and execution time, with buffer‑pool experiments confirming the improvement.

Subquerybuffer poolmysql
0 likes · 9 min read
Why Large OFFSETs Slow MySQL Queries and How Subquery Optimization Fixes It
21CTO
21CTO
Jan 10, 2022 · Backend Development

Mastering REST vs RESTful: Key Differences, Best Practices, and Future Trends

This comprehensive guide explains the origins and definitions of REST and RESTful, outlines core architectural constraints, compares terminology, presents best‑practice API design patterns—including URI conventions, HTTP methods, error handling, filtering, pagination, versioning, and health checks—while evaluating the future role of REST versus GraphQL.

HTTPVersioningapi-design
0 likes · 30 min read
Mastering REST vs RESTful: Key Differences, Best Practices, and Future Trends
NiuNiu MaTe
NiuNiu MaTe
Dec 15, 2021 · Databases

Master MySQL Performance: Practical Tuning, Indexes, and Scaling Strategies

This comprehensive guide walks through MySQL performance fundamentals, real‑world testing results, slow‑query detection, index impact, pagination pitfalls, count optimizations, sharding techniques, and step‑by‑step migration plans for large tables, equipping engineers with actionable tuning insights.

Index Optimizationdatabase scalingmysql
0 likes · 13 min read
Master MySQL Performance: Practical Tuning, Indexes, and Scaling Strategies
Java Interview Crash Guide
Java Interview Crash Guide
Dec 7, 2021 · Databases

Why Traditional Pagination Fails After Sharding and How to Solve It

When a table grows beyond ten million rows, sharding it across multiple databases improves performance, but the usual LIMIT offset, pagesize pagination breaks, leading to missing or incorrect records; this article examines why simple merge approaches fail and evaluates global, secondary query, and no‑skip paging strategies, highlighting their trade‑offs.

SQLdatabasemysql
0 likes · 12 min read
Why Traditional Pagination Fails After Sharding and How to Solve It
Senior Brother's Insights
Senior Brother's Insights
Oct 28, 2021 · Databases

Why MySQL LIMIT Can Return Duplicate Rows and How to Fix It

In a production environment, a pagination export feature caused duplicate and missing records due to MySQL’s nondeterministic ordering when multiple rows share the same ORDER BY value, and the article explains the root cause, official documentation, and a reliable solution using additional sorting columns.

LIMITOrder Byduplicate rows
0 likes · 10 min read
Why MySQL LIMIT Can Return Duplicate Rows and How to Fix It
IT Architects Alliance
IT Architects Alliance
Oct 14, 2021 · Backend Development

Best Practices for Designing Robust APIs

This article explains why APIs are essential, how to model data and resources, apply RESTful principles, choose clear naming conventions, manage versioning, and implement pagination, providing practical guidelines and code examples for building maintainable and developer‑friendly backend services.

Versioningapi-designpagination
0 likes · 8 min read
Best Practices for Designing Robust APIs
ITPUB
ITPUB
Oct 12, 2021 · Databases

How to Handle Pagination After MySQL Sharding: Pitfalls and Solutions

When a MySQL table is sharded into multiple databases or tables, the usual LIMIT offset, pagesize pagination breaks, and this article examines why simple merge fails, then presents three practical approaches—global limit, secondary queries, and jump‑page restriction—highlighting their trade‑offs and limitations.

SQLdatabasemysql
0 likes · 13 min read
How to Handle Pagination After MySQL Sharding: Pitfalls and Solutions
macrozheng
macrozheng
Oct 8, 2021 · Databases

How to Speed Up MySQL Deep Pagination: 4 Proven Optimization Techniques

This article explains why MySQL LIMIT deep pagination becomes slow with large offsets and presents four practical optimization methods—including subqueries, delayed INNER JOIN, tag‑recording, and BETWEEN…AND—demonstrated with real‑world production examples.

SQLmysqlpagination
0 likes · 11 min read
How to Speed Up MySQL Deep Pagination: 4 Proven Optimization Techniques
ITPUB
ITPUB
Aug 19, 2021 · Databases

Why Does MySQL LIMIT with ORDER BY Return Duplicate Rows on Page 2?

When using MySQL pagination with LIMIT together with ORDER BY, the second page can unexpectedly contain rows from the first page because MySQL 5.6's priority‑queue optimization performs an unstable heap sort, causing nondeterministic ordering for equal values and leading to duplicate results.

LIMITOrder Bydatabase
0 likes · 7 min read
Why Does MySQL LIMIT with ORDER BY Return Duplicate Rows on Page 2?
Tencent Cloud Developer
Tencent Cloud Developer
Aug 10, 2021 · Backend Development

Backend Storage Design for Timeline Feed Streams: Read Diffusion, Write Diffusion, and Hybrid Approaches

Backend storage for timeline feeds can use read‑diffusion (pull), write‑diffusion (push), or a hybrid mix, each with trade‑offs in read/write load, scalability, and storage, while pagination should rely on last_id and snapshots for state‑driven ordering such as live‑streaming feeds.

live streamingpaginationread diffusion
0 likes · 17 min read
Backend Storage Design for Timeline Feed Streams: Read Diffusion, Write Diffusion, and Hybrid Approaches
Ctrip Technology
Ctrip Technology
Jul 15, 2021 · Frontend Development

Optimizing List Rendering Performance in Taro3 Using a Custom Virtual List

This article examines the performance bottlenecks of a Taro3 mini‑program list page after migrating from Taro1, analyzes causes such as excessive node rendering and large setState payloads, evaluates backend pagination and the built‑in virtual list, and presents a custom virtual‑list implementation that reduces rendered nodes, uses screen‑height placeholders, and achieves roughly 45% faster rendering and 50% quicker interaction response.

IntersectionObserverReactTaro
0 likes · 12 min read
Optimizing List Rendering Performance in Taro3 Using a Custom Virtual List
DeWu Technology
DeWu Technology
Jul 2, 2021 · Databases

MySQL Deep Pagination Optimization

MySQL deep pagination can be dramatically accelerated by ordering on the primary key, indexing the sort column, and using keyset pagination or a sub‑query join instead of scanning millions of rows, while only minor tweaks like increasing sort_buffer_size provide negligible gains.

SQLdeep paginationindexing
0 likes · 10 min read
MySQL Deep Pagination Optimization
Top Architect
Top Architect
Jun 30, 2021 · Databases

Analyzing and Optimizing MySQL Pagination Performance with Large Offsets

This article investigates why MySQL queries with large LIMIT offsets become extremely slow, demonstrates the issue with simulated millions‑of‑row datasets, and presents three optimization strategies—including index‑covering subqueries, remembering the last primary‑key position, and applying offset throttling—to achieve consistent, fast pagination performance.

SQLindexinglarge datasets
0 likes · 12 min read
Analyzing and Optimizing MySQL Pagination Performance with Large Offsets
IT Xianyu
IT Xianyu
Jun 10, 2021 · Backend Development

Comprehensive Guide to MyBatis-Plus: CRUD, Annotations, Condition Builders, Pagination, and Advanced Features

This article provides a detailed tutorial on using MyBatis-Plus in Java, covering setup, entity and mapper definitions, CRUD operations, annotations, condition builders, pagination, AR mode, logical deletion, automatic field filling, optimistic locking, performance analysis, multi‑tenant support, dynamic table names, configuration options, and code generation.

CRUDJavaORM
0 likes · 45 min read
Comprehensive Guide to MyBatis-Plus: CRUD, Annotations, Condition Builders, Pagination, and Advanced Features
IT Architects Alliance
IT Architects Alliance
Jun 7, 2021 · Databases

Analyzing and Optimizing MySQL Pagination Performance with Large Offsets

The article examines a production MySQL query that suffers severe slowdown due to large LIMIT offsets, demonstrates how to reproduce the issue with massive test data, analyzes the root cause, and presents three optimization strategies—including index covering, keyset pagination, and offset limiting—to dramatically improve query performance.

SQLindexingmysql
0 likes · 13 min read
Analyzing and Optimizing MySQL Pagination Performance with Large Offsets
Architect
Architect
Jun 6, 2021 · Databases

Optimizing MySQL Pagination for Large Datasets: Analysis and Solutions

An engineer describes a production MySQL pagination issue where large offset queries caused severe slowdown, analyzes the root cause, demonstrates data simulation scripts, and presents three optimization strategies—including index covering with subqueries, redefining start positions, and applying offset limits—to improve query performance on massive tables.

Performance OptimizationSQLdatabase
0 likes · 13 min read
Optimizing MySQL Pagination for Large Datasets: Analysis and Solutions
Java Interview Crash Guide
Java Interview Crash Guide
May 30, 2021 · Backend Development

Master MyBatis-Plus with Spring Boot: CRUD, Pagination & Advanced Tips

This comprehensive tutorial demonstrates how to integrate MyBatis-Plus with Spring Boot, covering basic setup, entity and mapper creation, CRUD operations, condition wrappers, pagination, logical deletion, automatic field filling, optimistic locking, and advanced features such as multi‑tenant and dynamic table name handling, complete with code examples.

CRUDLogical DeletionSpring Boot
0 likes · 46 min read
Master MyBatis-Plus with Spring Boot: CRUD, Pagination & Advanced Tips
Code Ape Tech Column
Code Ape Tech Column
May 11, 2021 · Databases

How to Speed Up MySQL LIMIT Pagination for Millions of Rows

This article analyzes six MySQL pagination techniques, presents benchmark results showing how query time grows with offset, and offers practical index‑based optimizations—including covering indexes, subqueries, and composite index design—to make LIMIT pagination fast even on very large tables.

LIMITSQLindex
0 likes · 12 min read
How to Speed Up MySQL LIMIT Pagination for Millions of Rows
Architecture Digest
Architecture Digest
May 9, 2021 · Databases

Optimizing MySQL Pagination with LIMIT: Methods, Experiments, and Index Strategies

This article examines the performance drawbacks of MySQL's LIMIT pagination on large tables, presents six practical query methods—including direct LIMIT, primary‑key indexing, index‑based ordering, prepared statements, covering indexes, and sub‑query/join techniques—provides extensive benchmark results, and offers concrete indexing recommendations to achieve fast, stable pagination even with millions of rows.

LIMITLarge Dataindexing
0 likes · 12 min read
Optimizing MySQL Pagination with LIMIT: Methods, Experiments, and Index Strategies
Code Ape Tech Column
Code Ape Tech Column
May 8, 2021 · Databases

Understanding MySQL Pagination Performance and Index Optimization

The article explores why MySQL pagination with large offsets is slow, explains index structures such as clustered and secondary indexes, describes logical query operators, and presents two practical optimization strategies to improve query performance.

Database PerformanceIndex OptimizationQuery Planning
0 likes · 6 min read
Understanding MySQL Pagination Performance and Index Optimization
Programmer DD
Programmer DD
May 7, 2021 · Databases

Boost MySQL Pagination Performance: Real-World Tests and Optimizations

This article examines why full-table scans become slow on large MySQL tables, demonstrates various pagination techniques—including simple LIMIT, sub‑query, ID‑range, and IN‑clause methods—provides benchmark results for different record counts and offsets, and offers practical tips to dramatically speed up paginated queries.

Database PerformanceSQLmysql
0 likes · 10 min read
Boost MySQL Pagination Performance: Real-World Tests and Optimizations
Big Data Technology Architecture
Big Data Technology Architecture
May 6, 2021 · Databases

Elasticsearch Pagination: From+size, search_after, and Scroll – Differences, Advantages, and Use Cases

This article explains Elasticsearch’s three pagination methods—From + size, search_after, and Scroll—detailing their definitions, code examples, advantages, disadvantages, and suitable scenarios, while also discussing max_result_window limits, PIT views, and best practices for handling large result sets.

BackendElasticsearchSearch
0 likes · 13 min read
Elasticsearch Pagination: From+size, search_after, and Scroll – Differences, Advantages, and Use Cases
Programmer DD
Programmer DD
May 6, 2021 · Backend Development

Building a Fast Search with Redis: From Complex SQL to Set Operations

This article walks through the challenges of implementing a complex e‑commerce search interface, compares a naïve SQL solution with optimized multi‑query and Redis‑based approaches, and demonstrates how to use Redis sets, sorted sets, and transactions to achieve efficient querying, pagination, and data updates.

BackendSearchSet Operations
0 likes · 9 min read
Building a Fast Search with Redis: From Complex SQL to Set Operations
Code Ape Tech Column
Code Ape Tech Column
May 6, 2021 · Backend Development

Why PageHelper Pagination Breaks with List Operations and How to Fix It

This article explains why PageHelper pagination yields incorrect totals when list operations are performed before or after pagination, analyzes the underlying cause that startPage only affects subsequent SQL, and provides a step‑by‑step solution that processes the list after pagination and returns a correctly populated PageInfo object.

BackendJavaMyBatis
0 likes · 6 min read
Why PageHelper Pagination Breaks with List Operations and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
May 4, 2021 · Backend Development

Building a Reusable Backend Base Project with Swagger, CodeGenerator, Pagination, Exception Handling, and Multi‑Environment Configuration

This article explains how to create a reusable backend foundation for new Spring Boot projects by assembling common utilities such as Swagger API documentation, MyBatis‑Plus code generation, unified response objects, pagination helpers, custom exception handling, multi‑environment Maven and Spring profiles, logback configuration, and a Jenkins pipeline.

BackendException HandlingJava
0 likes · 15 min read
Building a Reusable Backend Base Project with Swagger, CodeGenerator, Pagination, Exception Handling, and Multi‑Environment Configuration
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2021 · Backend Development

Master MyBatis-Plus: From Basics to Advanced CRUD, Pagination, and Code Generation

This comprehensive guide walks you through MyBatis-Plus fundamentals, non‑intrusive features, quick project setup, CRUD operations, automatic field filling, optimistic and logical locking, powerful wrapper queries, pagination, and the built‑in code generator, all illustrated with runnable examples and code snippets.

CRUDCode GenerationJava
0 likes · 25 min read
Master MyBatis-Plus: From Basics to Advanced CRUD, Pagination, and Code Generation
Programmer DD
Programmer DD
Apr 6, 2021 · Databases

Why MySQL Pagination Is So Slow and How to Fix It

This article explores why MySQL queries with large LIMIT‑OFFSET pagination become painfully slow, explains the underlying B+‑tree index mechanics and MySQL's logical operator layers, and presents two practical solutions—key‑based pagination and index‑covering queries—to dramatically improve performance.

B+TreeDatabase PerformanceIndex Optimization
0 likes · 7 min read
Why MySQL Pagination Is So Slow and How to Fix It
MaGe Linux Operations
MaGe Linux Operations
Mar 20, 2021 · Backend Development

Mastering Elasticsearch Distributed Search: Performance Tips & Pagination Strategies

This article examines Elasticsearch’s distributed search architecture, explains the two‑phase query and fetch process, identifies performance and relevance scoring challenges, and presents optimization techniques such as Search After with point‑in‑time, Scroll API usage, and DFS query‑then‑fetch for accurate scoring.

Distributed SearchElasticsearchPerformance Optimization
0 likes · 9 min read
Mastering Elasticsearch Distributed Search: Performance Tips & Pagination Strategies
Code Ape Tech Column
Code Ape Tech Column
Mar 15, 2021 · Databases

Why Large OFFSETs Slow MySQL Queries and How to Fix Them

A developer discovers that massive OFFSET values in MySQL pagination cause full‑table scans and severe latency, then reproduces the issue with simulated data, benchmarks the slowdown, and presents three practical solutions—including index‑covering subqueries, cursor‑based pagination, and offset limits—to restore query performance.

Index OptimizationKeyset PaginationLarge OFFSET
0 likes · 16 min read
Why Large OFFSETs Slow MySQL Queries and How to Fix Them
php Courses
php Courses
Feb 22, 2021 · Backend Development

Customizing Laravel Pagination for Pseudo‑Static URLs

This guide explains how to override Laravel's built‑in pagination component to generate clean pseudo‑static URLs by creating a custom LengthAwarePaginator, rewriting its url method, and providing a staticPaginate scope for selective use.

BackendLaravelPHP
0 likes · 7 min read
Customizing Laravel Pagination for Pseudo‑Static URLs
Top Architect
Top Architect
Feb 17, 2021 · Backend Development

Understanding and Optimizing MyBatis PageHelper Pagination Performance

This article analyzes the performance bottlenecks of PageHelper's pagination in MyBatis, demonstrates how large offsets degrade MySQL query speed, and presents a more efficient sub‑query join solution along with suggestions for refactoring the interceptor to improve backend pagination efficiency.

BackendJavaMyBatis
0 likes · 9 min read
Understanding and Optimizing MyBatis PageHelper Pagination Performance
Code Ape Tech Column
Code Ape Tech Column
Jan 12, 2021 · Backend Development

How to Build a High‑Performance Search API with SQL and Redis Caching

This article walks through three progressively better implementations for a complex e‑commerce search API—starting with a monolithic SQL query, then splitting the query and adding indexes, and finally using Redis sets and sorted sets to cache filter results, handle pagination, and achieve production‑grade performance.

BackendSQLpagination
0 likes · 8 min read
How to Build a High‑Performance Search API with SQL and Redis Caching
21CTO
21CTO
Jan 5, 2021 · Databases

5 Essential Rules for Writing High‑Performance SQL Queries

This article presents five practical rules—return only needed rows, use proper indexes, avoid subqueries, replace OFFSET pagination with key‑based limits, and understand SQL's logical execution order—to help developers write efficient, high‑performance SQL queries across major relational databases.

SQLSubqueryindexes
0 likes · 13 min read
5 Essential Rules for Writing High‑Performance SQL Queries
ITPUB
ITPUB
Jan 3, 2021 · Databases

5 Essential Rules for Writing High‑Performance SQL Queries

This article presents five practical rules for optimizing SQL queries—including selecting only needed columns, ensuring proper indexes, avoiding subqueries, using keyset pagination instead of OFFSET, and understanding the logical execution order—along with concrete examples and execution‑plan analysis for major relational databases.

SQLexecution planindexes
0 likes · 14 min read
5 Essential Rules for Writing High‑Performance SQL Queries
Top Architect
Top Architect
Dec 16, 2020 · Backend Development

Integrating PageHelper with SpringBoot and MyBatis for Efficient Pagination

This article provides a comprehensive guide on integrating PageHelper with SpringBoot and MyBatis, covering development preparation, dependency configuration, basic and advanced usage patterns, code examples, and detailed explanations of pagination mechanisms, including PageParam design and MyBatis interceptor internals.

BackendJavaMyBatis
0 likes · 19 min read
Integrating PageHelper with SpringBoot and MyBatis for Efficient Pagination
Architect
Architect
Nov 17, 2020 · Databases

MySQL Pagination Optimization Techniques and Performance Testing

The article examines MySQL pagination performance on a large order_history table, presenting various pagination methods—including simple LIMIT, subquery, ID range, and temporary table techniques—along with detailed test results that show how query speed varies with record count and offset.

Performance Testingdatabasemysql
0 likes · 10 min read
MySQL Pagination Optimization Techniques and Performance Testing
Architecture Digest
Architecture Digest
Nov 5, 2020 · Databases

Elasticsearch Interview Question: Performance Optimization and Best Practices

The article explains how to improve Elasticsearch query speed on billions of records by leveraging filesystem cache, reducing indexed fields, using data pre‑heating, separating hot and cold indices, designing efficient document models, and applying pagination techniques such as scroll API and search_after.

BackendFilesystem Cachedata modeling
0 likes · 11 min read
Elasticsearch Interview Question: Performance Optimization and Best Practices
Top Architect
Top Architect
Oct 30, 2020 · Backend Development

Implementing Search with Redis: A Backend Development Case Study

This article demonstrates how to replace complex SQL search queries with a Redis‑based solution by caching intermediate result sets using sets and sorted sets, optimizing performance through multi‑command transactions, and adding pagination, offering a practical backend development pattern for high‑traffic e‑commerce search.

Performance OptimizationSQLSearch
0 likes · 9 min read
Implementing Search with Redis: A Backend Development Case Study
ITPUB
ITPUB
Oct 18, 2020 · Databases

Boost MySQL Pagination Speed: Practical Query Optimizations and Benchmarks

This article examines MySQL pagination on a multi‑million‑row table, compares plain LIMIT queries with subquery, ID‑range, and temporary‑table techniques, provides SQL examples and performance measurements, and offers recommendations for fast, scalable paging.

SQLmysqlpagination
0 likes · 10 min read
Boost MySQL Pagination Speed: Practical Query Optimizations and Benchmarks
Top Architect
Top Architect
Oct 1, 2020 · Backend Development

Implementing Pagination in Java Web Applications with Spring MVC and MyBatis

This article demonstrates how to implement pagination and search pagination in a Java web project using Spring MVC, MyBatis, and standard pagination utilities, covering the creation of a Page utility class, MyBatis mapper configurations, DAO interfaces, service methods, controller handling, and JSP view integration.

JavaMyBatisSpring MVC
0 likes · 10 min read
Implementing Pagination in Java Web Applications with Spring MVC and MyBatis
Programmer DD
Programmer DD
Sep 19, 2020 · Databases

Boost MySQL Pagination Performance: Proven Techniques and Benchmarks

This article examines various MySQL pagination strategies—including simple LIMIT clauses, sub‑query optimizations, ID‑range queries, and temporary‑table methods—by testing them on a table with millions of rows and presenting detailed timing results that reveal significant speed improvements.

LIMITPerformance Testingmysql
0 likes · 9 min read
Boost MySQL Pagination Performance: Proven Techniques and Benchmarks
Code Ape Tech Column
Code Ape Tech Column
Sep 16, 2020 · Backend Development

Unlock MyBatis Plugin Mechanics: Build Custom Interceptors and Pagination

This article explains MyBatis's plugin architecture, shows how to create a custom interceptor to modify query parameters, demonstrates injection into Spring Boot, and analyzes the underlying proxy generation and execution flow, including a brief look at the popular PageHelper pagination plugin.

InterceptorJavaMyBatis
0 likes · 12 min read
Unlock MyBatis Plugin Mechanics: Build Custom Interceptors and Pagination
IT Architects Alliance
IT Architects Alliance
Aug 29, 2020 · Databases

Why OFFSET/LIMIT Pagination Breaks at Scale and How to Use High‑Performance Keyset Pagination

The article explains why traditional OFFSET and LIMIT pagination becomes inefficient for large tables due to full‑table scans, demonstrates the performance gap with real‑world examples, and presents keyset (cursor‑based) pagination as a fast, index‑driven alternative with practical query patterns.

Database OptimizationKeyset PaginationOFFSET LIMIT
0 likes · 6 min read
Why OFFSET/LIMIT Pagination Breaks at Scale and How to Use High‑Performance Keyset Pagination
360 Quality & Efficiency
360 Quality & Efficiency
Jun 12, 2020 · Databases

MongoDB Pagination, Query Optimization, and Index Design Guide

This article explains various MongoDB pagination strategies—including skip/limit, range queries, and sorting—covers performance monitoring with profiling, details index creation and design principles, and describes how to interpret explain plans for efficient query optimization.

MongoDBdatabaseindexing
0 likes · 13 min read
MongoDB Pagination, Query Optimization, and Index Design Guide
Java Backend Technology
Java Backend Technology
Apr 23, 2020 · Databases

Why MySQL LIMIT Can Reverse ORDER BY in LEFT JOIN Queries

The author discovers a puzzling MySQL bug where moving the LIMIT clause outside a nested SELECT causes the final result set to be ordered incorrectly, explains how ORDER BY inside subqueries is ignored during LEFT JOIN processing, and recommends placing ORDER BY and LIMIT at the outermost query level.

JOINLIMITOrder By
0 likes · 5 min read
Why MySQL LIMIT Can Reverse ORDER BY in LEFT JOIN Queries
Laravel Tech Community
Laravel Tech Community
Apr 15, 2020 · Backend Development

Laravel Pagination: Using Query Builder, Eloquent, Simple Pagination, and Custom Views

This guide explains how Laravel's paginator integrates with the query builder and Eloquent ORM, shows basic and simple pagination methods, demonstrates manual paginator creation, customizing URIs, appending parameters, converting results to JSON, and customizing pagination views, all with code examples compatible with Bootstrap.

Backend DevelopmentBootstrapEloquent
0 likes · 10 min read
Laravel Pagination: Using Query Builder, Eloquent, Simple Pagination, and Custom Views
Architecture Digest
Architecture Digest
Mar 26, 2020 · Databases

MySQL Pagination Optimization Techniques and Performance Testing

This article examines various MySQL pagination methods—including simple LIMIT, offset impact, sub‑query, ID‑range, and temporary‑table strategies—provides detailed performance measurements on a table with over five million rows, and offers practical recommendations for speeding up large‑scale data retrieval.

SQLdatabasemysql
0 likes · 8 min read
MySQL Pagination Optimization Techniques and Performance Testing
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 6, 2019 · Backend Development

Why Your Java Service Breaks When Scaling and How to Fix It

This article examines five common Java backend pitfalls that startups face—single‑machine locking, improper multithreading, poorly defined workflows, unsafe system interactions, and non‑paginated queries—explains why they cause failures in distributed environments, and provides practical solutions such as distributed locks, message queues, state‑machine redesign, RPC interfaces, and pagination techniques.

JavaMessage Queuemultithreading
0 likes · 22 min read
Why Your Java Service Breaks When Scaling and How to Fix It
Tech Musings
Tech Musings
Oct 31, 2019 · Databases

Master MySQL Tricks: Upserts, Ignoring Errors, Joins, Pagination & More

This guide explores advanced MySQL techniques—including ON DUPLICATE KEY UPDATE for upserts, INSERT IGNORE to bypass errors, replacing subqueries with JOINs, handling LEFT JOIN pitfalls, efficient pagination strategies, multi‑table UPDATE/DELETE via JOIN, and the nuances of COUNT(*) versus COUNT(1).

Database OptimizationJOINSQL
0 likes · 12 min read
Master MySQL Tricks: Upserts, Ignoring Errors, Joins, Pagination & More
21CTO
21CTO
Jul 11, 2019 · Big Data

Boost Elasticsearch Queries on Billions of Docs: Filesystem Cache & Smart Design

Elasticsearch performance at billions‑scale can be dramatically improved by leveraging the OS filesystem cache, limiting indexed fields, separating hot and cold data, pre‑warming caches, and using scroll or search_after for pagination, while avoiding costly joins and ensuring the dataset fits in memory.

ElasticsearchFilesystem Cachedata modeling
0 likes · 12 min read
Boost Elasticsearch Queries on Billions of Docs: Filesystem Cache & Smart Design
Programmer DD
Programmer DD
Jul 2, 2019 · Databases

Why MySQL LIMIT Slows Down on Large Offsets and How to Fix It

This article analyzes why MySQL LIMIT pagination becomes increasingly slow with larger offsets, presents six optimization techniques—including using primary keys, covering indexes, prepared statements, subqueries, and composite indexes—and provides experimental results that demonstrate dramatic performance improvements.

Index OptimizationSQLmysql
0 likes · 12 min read
Why MySQL LIMIT Slows Down on Large Offsets and How to Fix It
Efficient Ops
Efficient Ops
Jun 28, 2019 · Databases

Master MySQL Optimization: 19 Practical EXPLAIN Tips and Best Practices

This guide presents nineteen essential MySQL optimization techniques—including effective use of EXPLAIN, proper handling of IN and EXISTS, avoiding SELECT *, limiting rows, optimizing ORDER BY, leveraging UNION ALL, employing full‑text indexes, and advanced join strategies—to help developers write faster, more efficient queries.

JOINSQL Optimizationexplain
0 likes · 12 min read
Master MySQL Optimization: 19 Practical EXPLAIN Tips and Best Practices
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Jun 25, 2019 · Mobile Development

Master iOS Pagination: Build Custom QiPageMenuView & QiPageContentView

This article explains how to create a flexible paginated interface in iOS using the custom QiPageMenuView and QiPageContentView components, covering implementation analysis, key properties, code examples, and two usage patterns that enable decoupled menu and content views for seamless scrolling and navigation.

Objective‑CQiPageContentViewQiPageMenuView
0 likes · 10 min read
Master iOS Pagination: Build Custom QiPageMenuView & QiPageContentView
ITPUB
ITPUB
Jun 18, 2019 · Databases

Why MySQL LIMIT Pagination Slows Down and 6 Proven Optimization Techniques

This article examines why MySQL LIMIT pagination becomes slower as the offset grows, presents six practical methods—including direct LIMIT, primary‑key indexing, ordered index scans, prepared statements, sub‑queries, and joins—provides benchmark results on large tables, and distills actionable guidelines for designing covering and composite indexes to achieve fast, stable pagination.

Index OptimizationLIMITSQL
0 likes · 12 min read
Why MySQL LIMIT Pagination Slows Down and 6 Proven Optimization Techniques
Architecture Digest
Architecture Digest
May 28, 2019 · Backend Development

Improving Elasticsearch Query Performance for Billion‑Scale Datasets

To boost Elasticsearch query speed on billions of records, allocate sufficient filesystem cache memory, store only searchable fields, separate hot and cold data, warm up cache, avoid complex joins, and replace deep pagination with Scroll API or search_after for millisecond‑level responses.

ElasticsearchFilesystem Cachedata modeling
0 likes · 10 min read
Improving Elasticsearch Query Performance for Billion‑Scale Datasets
Programmer DD
Programmer DD
May 26, 2019 · Databases

How to Speed Up Large‑Scale MySQL Pagination: Practical Tips & Benchmarks

This article explains why traditional MySQL pagination (ORDER BY … LIMIT N,M) becomes painfully slow on tens of millions of rows, analyzes the root causes, and presents concrete optimizations such as covering‑index delayed joins, bookmark‑based scans, and query rewrites that can cut execution time to a third of the original.

Bookmark Scancovering indexdelayed join
0 likes · 9 min read
How to Speed Up Large‑Scale MySQL Pagination: Practical Tips & Benchmarks
dbaplus Community
dbaplus Community
May 21, 2019 · Big Data

How to Supercharge Elasticsearch Queries on Billions of Records

This article explains why Elasticsearch can be slow on massive datasets, then details practical techniques—leveraging filesystem cache, pre‑heating hot data, separating hot and cold indices, designing lean document models, and avoiding deep pagination—to achieve sub‑second query performance at billions‑scale.

Big DataElasticsearchdata modeling
0 likes · 11 min read
How to Supercharge Elasticsearch Queries on Billions of Records
Java Backend Technology
Java Backend Technology
May 14, 2019 · Backend Development

Why Traditional PageSize/PageIndex Pagination Breaks with Dynamic Data—and How to Fix It

This article examines the pitfalls of using static pageSize and pageIndex parameters for pagination on rapidly changing data sets, illustrates how data shifts can cause duplicate or missing records, and proposes client‑side de‑duplication, server‑side last‑ID pagination, and business‑level tolerance strategies.

BackendDynamic Dataapi-design
0 likes · 6 min read
Why Traditional PageSize/PageIndex Pagination Breaks with Dynamic Data—and How to Fix It
Java Captain
Java Captain
Apr 6, 2019 · Backend Development

MyBatis Q&A: #{} vs ${}, Pagination Techniques, Caching, Lazy Loading, Executors, and Custom Plugin Development

This article explains MyBatis fundamentals including the difference between #{} and ${} placeholders, various pagination approaches, logical versus physical pagination, first‑ and second‑level caching, lazy‑loading mechanisms, executor types, pagination plugin principles, and how to create a custom MyBatis plugin with code examples.

Backend DevelopmentMyBatisSQL
0 likes · 8 min read
MyBatis Q&A: #{} vs ${}, Pagination Techniques, Caching, Lazy Loading, Executors, and Custom Plugin Development
Liangxu Linux
Liangxu Linux
Feb 20, 2019 · Databases

19 Essential MySQL Optimization Techniques Every Developer Should Know

This guide presents 19 practical MySQL optimization tips—including using EXPLAIN, avoiding SELECT *, limiting IN lists, preferring UNION ALL, improving pagination, leveraging full‑text indexes, and proper join strategies—to help developers write faster, more efficient queries.

Full‑Text SearchJOINSQL Best Practices
0 likes · 12 min read
19 Essential MySQL Optimization Techniques Every Developer Should Know
Qunar Tech Salon
Qunar Tech Salon
Dec 4, 2018 · Mobile Development

Zero‑Adapter Multi‑Item RecyclerView Library for Android

This article introduces an open‑source Android library that eliminates the need for custom RecyclerView adapters by using a ViewHolderManager system to handle multiple item types, headers, footers, click listeners, load‑more pagination, and animations, with complete code examples and usage guidelines.

AdapterAndroidMulti‑Item
0 likes · 12 min read
Zero‑Adapter Multi‑Item RecyclerView Library for Android
Youzan Coder
Youzan Coder
Nov 16, 2018 · Databases

Optimizing Large-Scale Pagination Queries in MySQL

When paginating millions of rows in MySQL, avoid large OFFSET scans by using delayed joins or bookmark techniques that first fetch primary‑key values via covering indexes, then retrieve the needed rows, dramatically reducing I/O and query latency.

bookmark paginationdatabasedelayed join
0 likes · 10 min read
Optimizing Large-Scale Pagination Queries in MySQL
360 Quality & Efficiency
360 Quality & Efficiency
Sep 29, 2018 · Databases

Diagnosing and Optimizing MySQL Query Performance Issues

This article explains how large data volumes and differing environments can degrade MySQL query performance, demonstrates using EXPLAIN to analyze index usage and row scans, and offers practical steps such as adding filters, pagination, and code adjustments to improve speed.

Environmentindexingmysql
0 likes · 6 min read
Diagnosing and Optimizing MySQL Query Performance Issues
Java Captain
Java Captain
Jun 21, 2018 · Backend Development

Step-by-Step Guide to Building a Spring Boot MyBatis Demo Project

This article provides a detailed tutorial for creating a Spring Boot project with MyBatis, including environment setup, Maven dependencies, configuration files, database creation, MyBatis generator usage, and sample controller, service, and mapper code, enabling pagination with PageHelper and testing via HTTP requests.

Backend DevelopmentCode GenerationJava
0 likes · 14 min read
Step-by-Step Guide to Building a Spring Boot MyBatis Demo Project
21CTO
21CTO
Apr 27, 2018 · Backend Development

How Stack Overflow Achieves Lightning‑Fast Pagination

This article explains the sophisticated pagination system used by Stack Overflow, covering offset‑based queries, a custom Tag Engine, database joins, in‑memory sorting, and caching techniques that together deliver rapid page navigation even over billions of records.

Backenddatabasepagination
0 likes · 6 min read
How Stack Overflow Achieves Lightning‑Fast Pagination
ITPUB
ITPUB
Mar 23, 2018 · Databases

Why Classic MySQL Pagination “Optimization” Often Fails and When It Actually Helps

This article investigates the classic MySQL pagination “optimization” technique, reproduces tests on a low‑end server, compares plain LIMIT queries with the sub‑query rewrite on both clustered and non‑clustered indexes, and explains why the method sometimes improves performance and sometimes adds overhead.

SQLindexmysql
0 likes · 15 min read
Why Classic MySQL Pagination “Optimization” Often Fails and When It Actually Helps
Java Captain
Java Captain
Mar 20, 2018 · Backend Development

Implementing Pagination in a Java Web Application with Spring MVC and MyBatis

This article demonstrates how to implement page-based data retrieval in a Java web application using Spring MVC, MyBatis, and a custom Page utility class, covering the creation of the pagination class, mapper XML, DAO interfaces, service logic, controller handling, and JSP pagination controls.

BackendJavaMyBatis
0 likes · 10 min read
Implementing Pagination in a Java Web Application with Spring MVC and MyBatis
Tencent TDS Service
Tencent TDS Service
Feb 1, 2018 · Backend Development

How a TV App’s Waterfall Layout Boosted User Engagement and Efficiency

This article details the redesign of a TV app from a horizontal layout to a waterfall flow, explaining the project timeline, advantages, new seven‑layer architecture, CMS‑driven configuration, compatibility handling, pagination strategies, caching, and fault‑tolerance measures that together improved user conversion and system robustness.

Backend ArchitectureCMSTV app
0 likes · 36 min read
How a TV App’s Waterfall Layout Boosted User Engagement and Efficiency
Beike Product & Technology
Beike Product & Technology
Nov 27, 2017 · Frontend Development

Implementing Scroll-Based Lazy Loading, Event Throttling, and Request Locking for Frontend Pagination

This article explains how to replace traditional pagination with scroll‑triggered lazy loading, using a 200 px threshold, 60 ms event throttling, a loading‑state lock, UI feedback, error handling, and cross‑platform scroll compatibility to improve user experience on web and mobile pages.

JavaScriptevent-throttlinglazy loading
0 likes · 6 min read
Implementing Scroll-Based Lazy Loading, Event Throttling, and Request Locking for Frontend Pagination