The article explains how ORM bridges Python objects and relational databases, compares options, and justifies choosing the lightweight Peewee library, then details its workflow—model generation, inserting, updating, deleting, and querying records—showcasing how this approach reduces manual data‑creation time from hours to seconds.
The article introduces MyBatis‑Pro, a Spring‑Boot starter that eliminates manual single‑table SQL by generating CRUD methods through naming conventions, explains quick integration, core features, configuration options, entity annotations, logical‑delete strategies, generic services, and provides extensive code examples for developers.
RedisOM, the official Redis ORM for Java, lets Spring Boot developers replace RedisTemplate with object‑oriented data handling and built‑in full‑text search, covering JDK 11 setup, Maven dependencies, configuration, entity annotations, repository interfaces, and REST controller examples for managing product data.
An in‑depth guide shows how running 100 concurrent MyBatis queries triggers a ClassCastException, explains the underlying cache placeholder issue, and demonstrates how Spring Boot’s SqlSessionTemplate and transaction management guarantee thread‑safe SqlSession usage through ThreadLocal binding.
This article provides a comprehensive overview of MyBatis, detailing its three‑layer architecture, core modules such as caching, reflection, and transaction management, as well as the complete execution process from configuration files to SQL execution, helping developers master the framework for enterprise‑level Java applications.
This article explains MyBatis's first‑level and second‑level caching mechanisms, demonstrates data inconsistency problems caused by joined‑table queries, and provides a custom annotation‑driven relation cache solution with code examples for configuring and validating the cache behavior.
This article explains how MyBatis' ${} and #{} placeholders differ in SQL generation, demonstrates their usage with code examples, analyzes the SQL injection risks of ${} versus the safety of #{} through prepared statements, and provides practical guidelines for choosing the appropriate placeholder in various scenarios.
This article explains MyBatis dynamic SQL, covering its purpose, the distinction between static and dynamic SQL, the core SqlNode and SqlSource classes, how MyBatis parses and assembles SQL scripts recursively, and provides concrete code examples to illustrate each step.
This article walks through setting up GORM in a Go project, covering dependency management, database initialization, model definition, and practical examples of select, insert, update, delete, raw SQL execution, and transaction handling with detailed code snippets.
This article explains how MyBatis' ${} and #{} placeholders differ in syntax substitution and security, demonstrates their usage with DAO interfaces, Mapper XML, and JUnit tests, analyzes SQL injection risks, shows the underlying PreparedStatement handling, and provides practical guidelines for when to use each placeholder.
MyBatis-Plus, a MyBatis enhancement toolkit, streamlines CRUD development, celebrates its fifth consecutive OSC popularity award, and introduces version 4.0 with a comprehensive update log that includes MyBatis 3.5.9 upgrade, dynamic mapper injection, new hooks, and numerous performance and compatibility improvements.
The article introduces a lightweight Go ORM for MySQL, explains native connection setup, details the SmallormEngine design with chainable methods for Table, Where, Insert, Update, Delete, and BatchInsert, and demonstrates how reflection builds SQL fragments while handling errors and supporting fluent query composition.
Learn how Bean Searcher enables Java backend developers to replace dozens of lines of ORM code with a single, flexible query method, supporting multi-table joins, dynamic filters, pagination, sorting, and custom operators, dramatically boosting development efficiency for complex list retrieval scenarios.
This article introduces the Java Persistence API (JPA), explains why Spring Data JPA has become an essential skill for large companies, outlines its benefits for development efficiency and career growth, and recommends the comprehensive book “Spring Data JPA: From Basics to Advanced” with its detailed structure and practical examples.
This article explains how Mybatis-Plus extends MyBatis by injecting dynamic configuration XML, customizing mapper registration, and generating CRUD SQL statements through classes like MybatisSqlSessionFactoryBuilder, MybatisConfiguration, MybatisMapperRegistry, and various AbstractMethod implementations.
This article introduces MyBatis-PageHelper, a universal pagination plugin that supports a wide range of databases, explains how to configure custom dialect aliases, shows Maven and Spring integration, details numerous plugin parameters, and provides multiple code examples for various usage patterns.
This article demonstrates how to use Fluent Mybatis, native Mybatis, and Mybatis‑Plus to implement a complex student‑score aggregation query, compares their code structures, generation settings, and highlights the advantages and drawbacks of each approach for backend development.
This article introduces MyBatis‑Mate, an official MyBatis‑Plus extension that provides enterprise‑grade capabilities such as sharding, data auditing, field encryption, dictionary binding, sensitive data masking, automatic DDL maintenance, dynamic data‑source switching, performance logging, and fine‑grained data‑scope control, all illustrated with practical code examples.
This article provides a comprehensive overview of MyBatis, covering its purpose as a semi‑automatic persistence framework, the reasons for using ORM, how to download and build the source, its core workflow, layered architecture, and detailed configuration parsing with code examples.
This article explains how MyBatis plugins work, shows how to create a custom interceptor with Java code, configure it in XML, and details the underlying mechanism that uses dynamic proxies to intercept Executor methods.
This article demonstrates how to implement a student score statistics query—calculating count, minimum, maximum, and average scores per term and subject—using Fluent MyBatis, native MyBatis, and MyBatis‑Plus, comparing code complexity, configuration, and generated code across the three approaches.
This article provides a detailed introduction to MyBatis, covering its relationship with JDBC, core components, execution flow, configuration, design patterns, caching strategies, plugin mechanisms, logging options, dynamic SQL features, and includes complete Java and XML code examples to illustrate practical usage.
The article presents mybatis-mate, an enterprise‑grade MyBatis module that provides sharding, data auditing, sensitive‑word filtering, field encryption, dictionary write‑back, data permission, automatic DDL maintenance, dynamic multi‑datasource switching, and distributed transaction logging, offering developers a more agile and elegant way to handle data.
This article demonstrates how to extend MyBatis‑Plus to support ClickHouse-specific SQL operations by creating custom enum definitions, method classes, a SQL injector, a super mapper interface, and accompanying unit tests, enabling update, delete, and logical delete functionalities that differ from standard MySQL behavior.
This tutorial walks through installing the Go XORM library, generating Go structs from existing MySQL tables with the reverse tool, and demonstrates full CRUD, pagination, and transaction handling using both chainable queries and raw SQL.
This article explains MyBatis’s internal workflow, covering how mapper interfaces bind to XML files, the step‑by‑step SQL execution pipeline, parameter handling, result set mapping, and how to create custom TypeHandler classes for both input parameters and query results.
This article compares Fluent Mybatis, native Mybatis, and Mybatis Plus by implementing a student score aggregation query, showing code examples, generation settings, and a summary of advantages and drawbacks to help developers choose the most efficient ORM for complex SQL operations.
The article evaluates major Java persistence solutions—Hibernate, MyBatis, JOOQ, Ebean, Spring Data JPA and JDBC Template—by comparing their SQL encapsulation, DSL support, cross‑database portability, performance, and security, ultimately recommending JDBC Template for the author's project.
This article provides a comprehensive overview of core Python concepts—including garbage collection, tuple versus list differences, process/thread/coroutine models, shallow and deep copying, the Global Interpreter Lock, sorting algorithms, closures, decorators, iterators, generators, and essential Django backend components such as WSGI, request lifecycle, middleware, ORM methods, caching, and REST framework.
This tutorial walks through ten advanced Django ORM QuerySet methods—exclude, values, values_list, select_related, order_by, exists, count, first/last, in_bulk, and explain—showing how each works with practical code examples using Student and School models.
This article provides a thorough introduction to MyBatis, including a complete beginner example with database schema, Maven configuration, XML and Java mapper files, and a demo program, followed by an in‑depth explanation of MyBatis’s lifecycle, core components such as SqlSession, Executor, StatementHandler, ParameterHandler, ResultSetHandler, and their interactions.
The article presents a step‑by‑step MyBatis tutorial that creates a sample user table, adds Maven dependencies, configures MyBatis, defines mapper XML and Java interfaces, demonstrates a test program, and explains core components such as SqlSession, Executor, StatementHandler, ParameterHandler, and ResultSetHandler.
This article evaluates popular and niche Java persistence frameworks—Hibernate, MyBatis, JOOQ, Ebean, JPA, and Spring JDBC Template—by comparing SQL encapsulation, performance, DSL support, cross‑database portability, and security, ultimately explaining why the author chose JDBC Template for their project.
This article demonstrates how Fluent Mybatis can build complex SQL without XML, compares its implementation with native Mybatis and Mybatis‑Plus for a student score statistics query, and reviews code‑generation settings and feature overviews to help developers choose the most efficient data‑access framework.
This article explains why Core Data is needed for iOS data persistence, introduces its concepts such as entities, attributes, relationships, and ORM, walks through creating a data model file, configuring NSPersistentContainer, and demonstrates full CRUD operations with Swift code examples and best‑practice tips.
This tutorial explains how to connect a Python program to a MySQL database in three clear steps—installing the driver, using it with basic connection code, and optionally employing an ORM like Peewee for higher‑level database interactions—complete with ready‑to‑run examples.
This guide explains how to install the MySQL driver for Python, establish a connection to a MySQL database using MySQLdb, execute queries, and optionally use ORM libraries such as SQLAlchemy or Peewee for higher‑level database interactions.
BytePush introduces a quality assurance platform that automates risk detection, streamlines QA and R&D collaboration through customizable cards, database ORM improvements, and a three‑stage evolution toward intelligent alerts, saving manpower and improving release quality.
This article explains how SQL injection can still occur in Java applications using MyBatis, describes the three typical vulnerable patterns (LIKE, IN, ORDER BY), and provides a step‑by‑step practical workflow—including code snippets and verification—to help beginners audit and remediate such issues.
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.
This article explains how to set up the MyBatis Generator plugin in a Maven project, configure generatorConfig.xml and jdbc.properties, and demonstrates practical CRUD operations such as deleting users, updating team information, and performing fuzzy and range queries with generated Example classes.
This article provides a detailed tutorial on using MyBatis-Plus with Spring Boot, covering installation, quick start, CRUD operations, annotation usage, condition builders, pagination, AR mode, primary key strategies, configuration options, code generation, logical deletion, auto-filling, optimistic locking, performance analysis, multi‑tenant support, dynamic table names, and best‑practice summaries.
This article provides a detailed tutorial on using MyBatis‑Plus with Spring Boot, covering quick setup, entity and mapper definitions, CRUD operations, condition wrappers (including lambda and chain wrappers), pagination, ActiveRecord mode, primary‑key strategies, configuration options, code generation, and advanced features such as logical deletion, auto‑fill, optimistic locking, performance analysis, multi‑tenant and dynamic table name handling.
This guide shows three practical ways—using the queryset query attribute, Django's connection object, and the Django Debug Toolbar—to inspect the raw SQL generated by Django ORM, helping developers optimize database performance and troubleshoot queries effectively.
MyBatis‑Plus enhances MyBatis by automatically injecting CRUD SQL via BaseMapper, using entity annotations and template methods to map classes to tables, eliminating repetitive manual SQL, supporting lambda queries, pagination, and performance tools, all with minimal intrusion and overhead.
This article thoroughly dissects MyBatis’s internal workflow, explaining how mapper interfaces are linked to XML files, detailing the step‑by‑step SQL execution process, and demonstrating custom typeHandler creation for both parameter and result mapping, all based on MyBatis 3.5.5 source code.
This comprehensive guide explains what MyBatis is, its advantages and drawbacks, usage scenarios, differences from Hibernate, key syntax like #{ } vs ${ }, mapping techniques, pagination, caching, lazy loading, batch operations, dynamic SQL, and how to configure mappers and plugins in Java projects.
EasyJDBC is a Java library built on Spring's JdbcTemplate that adds JPA‑style annotations, dynamic entity mapping, chainable query APIs, and broad database support, with Maven coordinates for both core and Spring Boot starter packages and a detailed changelog for version 2.1.0.
This article provides a comprehensive overview of MyBatis, covering its definition as a semi‑ORM persistence framework, core architecture, key components, advantages and drawbacks, practical usage patterns, and a collection of common interview questions with detailed answers for Java developers.
This tutorial explains how to use ThinkPHP6's Db facade to perform MySQL SELECT queries with the query method and INSERT/UPDATE operations with the execute method, including required imports and example code snippets.
This article provides a step‑by‑step tutorial on using MyBatis‑Plus with Spring Boot, covering database creation, table definition, Maven dependencies, entity and mapper setup, CRUD operations, automatic field filling, optimistic locking, pagination, logical deletion, performance monitoring, query wrappers, and code generation, all illustrated with complete code examples.
This article provides a comprehensive overview of MyBatis, a semi‑ORM Java framework, covering its core concepts, benefits, drawbacks, appropriate use cases, differences from Hibernate, parameter handling, dynamic SQL, caching, lazy loading, mapper binding, plugin development, and various configuration techniques.
This comprehensive guide explains what MyBatis is, its advantages and drawbacks, suitable use cases, differences from Hibernate, parameter handling, dynamic SQL, pagination, caching, lazy loading, and how to use mapper interfaces, XML mappings, and plugins with clear code examples.
This article compares JDBC Template, MyBatis, JOOQ, Hibernate, and JPA, analyzing their SQL encapsulation, performance, DSL support, cross‑database portability, and security to explain why the author ultimately chose JDBC Template for Java data persistence.
This article provides a detailed walkthrough of ThinkPHP's Db class, explaining how it combines connectors, query builders, and SQL generators to perform database operations, including method calls like __callStatic, table handling, where clause parsing, getLastSql retrieval, and the underlying execution flow.
This article provides a detailed walkthrough of the ThinkPHP Db class, explaining its relationship with other core classes, the database configuration, and the step‑by‑step execution flow of queries, including magic methods, connection handling, and result retrieval.
This article provides a comprehensive, step‑by‑step analysis of ThinkPHP's Model class, illustrating how the framework organizes model files, utilizes traits and ArrayAccess, and executes the save method—including data validation, insert/update logic, and the underlying execute routine that interacts with the database via PDO.
This article introduces MyBatis-Plus, explains its non‑intrusive features, demonstrates how to add Maven dependencies, examines the built‑in batch insert API, and provides step‑by‑step code to extend BaseMapper with a custom EasyBaseMapper for efficient MySQL batch inserts.
This article explains how MyBatis supports plugins, covering configuration, how to write an Interceptor, the runtime mechanism, registration timing, initialization process, and the principles behind pagination plugins, with detailed code examples and annotations.
This tutorial walks through high‑level Django ORM techniques—including aggregation, grouping, field‑to‑field (F) expressions, complex Q‑object queries, and dynamic query construction—providing clear code examples, SQL equivalents, and practical tips for backend developers working with Python and databases.
This article walks through Django ORM's advanced query techniques, covering foreign‑key field access, reverse lookups with __set and related_name, double‑underscore cross‑table filters, values and values_list usage, and chaining multiple filter calls for flexible data retrieval.
Learn how to design a simple book management database, define Django models for authors, publishers, books and their many‑to‑many relationships, and perform common ORM operations such as retrieving all records, filtering with conditions, using first(), get(), and inspecting the generated SQL.
This article provides a comprehensive step‑by‑step guide on using MyBatis‑Plus in a Spring Boot application, covering table creation, Maven dependencies, configuration, entity and mapper definitions, CRUD testing, auto‑fill, optimistic and logical deletion, pagination, performance monitoring, query wrappers, and code generation.
ebatis is an Elasticsearch ORM framework that simplifies query building by providing a MyBatis-like interface, eliminating the need for manual DSL construction and enabling seamless version upgrades.
This article explains MyBatis dynamic SQL features—including if, choose, trim, foreach, and bind tags—by showing how to set up a Maven project, create a student table, write mapper methods, and run tests that demonstrate conditional queries, updates, inserts, batch operations, and database‑agnostic expressions.
The article analyzes recent Google Trends, Stack Overflow statistics, and a Twitter poll to compare the popularity of MyBatis and Hibernate, then presents the author’s perspective on why MyBatis is often preferred for fast‑paced internet applications despite its trade‑offs.
This article walks through using Google’s Room ORM in an Android project to create a SQLite database, define entities and DAOs, set up a singleton database instance, and implement add, query, fuzzy search, and delete operations via a simple UI.
This article provides concise, interview‑style explanations of MyBatis core concepts—including the difference between #{} and ${}, additional XML tags, DAO interface mechanics, pagination, plugin development, batch operations, executors, lazy loading, enum mapping, and internal configuration mapping—helping developers ace backend Java ORM interviews.
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.
This article explains how MyBatis loads its global configuration, parses mapper files, builds SqlSessionFactory and SqlSession, and executes SQL statements through a series of internal components such as Executor, StatementHandler, and caches, illustrated with detailed code snippets.
MyBatis-Plus (MP) is a non‑intrusive MyBatis enhancement tool that offers a rich set of CRUD features, multi‑database support, code generation, and plugins, and this article explains its key capabilities, architecture diagram, and provides a step‑by‑step quick‑start example with Maven dependencies and sample query code.
The article describes how the Wukong Activity Platform’s data‑persistence layer uses Node.js as a BFF with MySQL, combines raw drivers, optional ORMs, and a custom lightweight Node‑MyBatis framework that offers dynamic SQL templating, built‑in injection protection, declarative transaction decorators, and automatic TypeScript type generation for full‑stack JavaScript development.
This tutorial demonstrates how to leverage MyBatis dynamic SQL features—including if, choose, trim, foreach, and bind tags—to build flexible SELECT, INSERT, UPDATE, and DELETE statements with conditional logic, code examples, and test cases for Java backend development.
This article introduces SQLAlchemy as a Python ORM, shows how to install and configure it in a Flask project, defines Article and Article_Detail models, demonstrates CRUD routes, explains database migration with Flask‑Migrate, and covers comment handling and rollback procedures.
This tutorial demonstrates how to integrate both Hibernate and MyBatis ORM frameworks within a single Spring Boot application, covering environment setup, project configuration, entity and repository definitions, service and controller implementation, and testing to verify concurrent operation.
This article explains how MyBatis dynamic SQL tags such as if, choose, trim, foreach, and bind can be used to build flexible SELECT, INSERT, UPDATE, and DELETE statements, showing code examples, test cases, and best‑practice tips for handling optional parameters and batch operations in Java backend development.
This article explains what MyBatis TypeHandler is, how to configure the environment, create custom handlers, register them via Spring Boot or XML, and details the internal execution flow for converting parameters and results between Java and JDBC types.
This article introduces MyBatis's underlying architecture by explaining the six core interfaces—SqlSession, Executor, StatementHandler, ParameterHandler, ResultSetHandler, and TypeHandler—detailing their roles, key methods, caching mechanisms, and how they are instantiated within a Spring Boot environment.
This article explains MyBatis result mapping techniques—including alias mapping, camel‑case automatic mapping, explicit resultMap definitions, and advanced one‑to‑one and one‑to‑many associations—providing code examples, configuration details, and performance considerations such as the N+1 query problem.
This tutorial walks through integrating MyBatis with Spring Boot, covering Maven dependencies, datasource configuration, mapper scanning, basic CRUD XML mappings, the differences between #{ } and ${ }, auto‑generated key handling, SQL fragments, and enabling camel‑case mapping for seamless Java‑to‑database interaction.
This tutorial explains how to use MyBatis dynamic SQL tags such as if, choose, trim, foreach, and bind to build flexible SELECT, UPDATE, INSERT, and batch statements, demonstrating data preparation, conditional query construction, selective updates, conditional inserts, and advanced tag usage with complete Java test examples.
This article provides a comprehensive tutorial on using EF Core in .NET, covering DbContext setup for MySQL and SQL Server, thread‑safety considerations, connection‑pooling benefits, logging of generated SQL, various insertion techniques (single, cascade, bulk), querying methods, and efficient update patterns.
This article presents a systematic performance test of Hibernate and MyBatis covering bulk inserts, single‑table queries, and various association queries on MySQL, analyzes the impact of lazy versus eager loading, caching, and data volume, and provides practical recommendations for choosing the appropriate ORM framework.
This article introduces MyBatis‑Plus, a powerful Java ORM that eliminates the need for manual XML mappings by providing ready‑made CRUD APIs, demonstrates how to configure Maven dependencies, define entity and mapper classes, and implement common database operations such as insert, delete, update, select, pagination, and complex conditional queries within a Spring Boot controller, all while showing the generated SQL statements.
Hibernate ORM 5.4.20, a popular Java object‑relational mapping framework, introduces several bug fixes, new tasks such as CockroachDB support, and performance improvements, aiming to simplify database persistence and reduce manual SQL/JDBC coding for developers.
The article presents Sponsor, a lightweight ORM‑style wrapper for Android’s native SQLite that uses runtime annotations and dynamic proxies to generate Retrofit‑like, type‑safe CRUD APIs, automatically handling table creation, upgrades, and threading while keeping performance overhead negligible for SDK developers.
This article provides a comprehensive guide to MyBatis dynamic SQL, covering essential tags such as if, choose, trim, foreach, and bind, with practical Maven project setup, full SQL examples, and JUnit tests that demonstrate conditional queries, updates, inserts, and batch operations.
The article examines a Spring‑related Twitter poll, Google Trends, and Stack Overflow statistics to compare MyBatis, Hibernate, and JPA, then argues that MyBatis’ simplicity and flexibility make it better suited for today’s fast‑paced backend development.
This article explains how to use MyBatis dynamic SQL tags such as if, choose, trim, foreach, and bind, providing detailed examples of conditional queries, updates, inserts, and batch operations with accompanying Java and XML code.
This article demonstrates how to set up Sharding-JDBC in a Spring Boot project, covering project structure, Maven configuration, entity, controller, service, mapper code, database DDL for multiple shards, sharding rules in application.properties, and API testing with Postman.
An upgrade of MyBatis from 3.2.3 to 3.4.6 caused parameterType mismatches in XML mappings, turning previously ignored type declarations into enforced ones, which led to ClassCastException errors for LocalDateTime and other types, prompting a root‑cause analysis and recommendations for careful version testing and configuration alignment.
This article explains how to define and use Laravel Eloquent relationships—including one-to-one, inverse, and default model handling—by showing the necessary model methods, query constraints, and code examples for both sides of the association.
This article explains how to add, update, and manage related Eloquent models in Laravel—including saving single or multiple related records, using associate/dissociate for belongsTo relations, and handling many‑to‑many pivots with attach, detach, sync, toggle, and timestamp propagation.
This article explains Laravel Eloquent's eager loading techniques, demonstrating how to replace lazy-loaded N+1 queries with the with() method, preload multiple or nested relationships, select specific columns, apply constraints, and use lazy eager loading methods like load and loadMissing, all illustrated with PHP code examples.
This article explains how to define and use Laravel Eloquent relationships—including remote one‑to‑many (hasManyThrough), polymorphic, many‑to‑many polymorphic, and various query constraints—by showing required database schemas, model methods, and example code for retrieving and counting related records.
This article explains how to define many-to-many relationships in Laravel's Eloquent ORM, covering the required pivot table, model methods, query constraints, pivot customization, and the use of custom pivot models with code examples.
This article explains how to define and use one-to-many and inverse (belongsTo) relationships in Laravel's Eloquent ORM, including default foreign key conventions, accessing related records, applying query constraints, and customizing foreign and local keys with code examples.
This article explains the powerful MyBatis resultMap element, covering basic getter/setter injection, constructor injection, inheritance, one-to-one and one-to-many associations, and discriminators, while providing complete XML examples and Java entity code to help developers map complex relational data efficiently.
A deep dive into recent Spring team poll results, Google Trends, Stack Overflow statistics, and expert opinions reveals why MyBatis is often preferred over Hibernate for fast‑moving, internet‑scale Java applications.
This article explains the differences between Laravel's ORM and DB query builder, outlines their advantages and appropriate use cases, and provides step‑by‑step code examples for defining models, retrieving, creating, and deleting records, as well as handling transactions.
