GitHub - faridonfire/ObjectiveSql: ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least and convention over configuration.

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Reference documentation

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Reference documentation

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Reference documentation

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Reference documentation

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Reference documentation

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Reference documentation

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Reference documentation

ObjectiveSQL is an ORM framework in Java based on ActiveRecord pattern, which encourages rapid development and clean, codes with the least, and convention over configuration.

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many and beglongs_to) query and paged query
Writing SQL expressions(arithmetic, comparison and logical) using Java syntax

Installation

IntelliJ IDEA plugin installation

Preferences/Settings -> Plugins -> Search with "ObjectiveSql" in market -> Install

Maven dependencies

<!-- In standalone -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objective-sql</artifactId>
<version>1.4.3</version>
</dependency>

<!-- In Spring Boot -->
<dependency>
<groupId>com.github.braisdom</groupId>
<artifactId>objsql-springboot</artifactId>
<version>1.3.1</version>
</dependency>

Refer to the pom.xml for more configuration

Examples

ObjectiveSQL provides full example for various databases below, You can open it directly with IntelliJ IDEA as a standalone project. In fact, they are not just examples, but also unit tests of ObjectiveSQL in various databases.

If you want to run without configuration, you can try: SQLite

Others: MySQL, Oracle, MS SQL Server, PostgreSQL, Spring Boot

Simple SQL programming without coding

You just define a JavaBean with one annotation your Class has fully capabilities of featured database access

@DomainModelpublicclassMember {
privateStringno;
@QueryableprivateStringname;
privateIntegergender;
privateStringmobile;
privateStringotherInfo;
@Relation(relationType = RelationType.HAS_MANY)
privateList<Order> orders;
}

Persistence

Member.create(newMember);
Member.create(newMember, true); // Create a member without validatingMember.create(Member.newInstanceFrom(memberHash));
Member.create(newMember[]{newMember1, newMember2, newMember3}, false);
Member.update(1L, newMember, true); // Update a member with primary keyMember.update("name = 'Smith => Jackson'", "name = 'Alice'");
Member.destroy(1L); // Delete a member with primary keyMember.destroy("name = 'Mary'");
// Execute SQLMember.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Counting and querying

Member.countAll();
Member.count("id > ?", 1);
Member.queryByPrimaryKey(1);
Member.queryFirst("id = ?", 1);
Member.query("id > ?", 1);
Member.queryAll();

Paged querying

Pagepage = Page.create(0, 10);// Create a Page instance with current page and page sizePagedList<Member> members = Member.pagedQueryAll(page, Member.HAS_MANY_ORDERS);

Relation querying

// Querying objects with convenient methods, and it will carry the related objectsMember.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);
...

Complex SQL programming

// SQL programming with Java syntax without losing the features of SQL syntaxOrder.TableorderTable = Order.asTable();
Selectselect = newSelect();
select.project(sum(orderTable.amount) / sum(orderTable.quantity) * 100)
.from(orderTable)
.where(orderTable.quantity > 30 &&
orderTable.salesAt.between("2020-10-10 00:00:00", "2020-10-30 23:59:59"))
.groupBy(orderTable.productId);

-- SQL syntax is the same as Java syntaxSELECT ((((SUM(`T0`.`amount` ) /SUM(`T0`.`quantity` ) )) *100))
FROM`orders`AS`T0`WHERE ((`T0`.`quantity`>30) AND`T0`.`sales_at` BETWEEN '2020-10-10 00:00:00'AND'2020-10-30 23:59:59')
GROUP BY`T0`.`product_id`

Name		Name	Last commit message	Last commit date
benchmark		benchmark
core		core
examples		examples
javaoo_test		javaoo_test
mangosdk		mangosdk
springboot		springboot
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pom.xml		pom.xml

Name		Name	Last commit message	Last commit date
benchmark		benchmark
core		core
examples		examples
javaoo_test		javaoo_test
mangosdk		mangosdk
springboot		springboot
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pom.xml		pom.xml

Name		Name	Last commit message	Last commit date
benchmark		benchmark
core		core
examples		examples
javaoo_test		javaoo_test
mangosdk		mangosdk
springboot		springboot
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pom.xml		pom.xml

Name		Name	Last commit message	Last commit date
benchmark		benchmark
core		core
examples		examples
javaoo_test		javaoo_test
mangosdk		mangosdk
springboot		springboot
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pom.xml		pom.xml

Name		Name	Last commit message	Last commit date
benchmark		benchmark
core		core
examples		examples
javaoo_test		javaoo_test
mangosdk		mangosdk
springboot		springboot
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
pom.xml		pom.xml

Latest commit

History

Folders and files

Repository files navigation

Features

Installation

IntelliJ IDEA plugin installation

Maven dependencies

Examples

Simple SQL programming without coding

Persistence

Counting and querying

Paged querying

Relation querying

Complex SQL programming

Reference documentation

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Features

Installation

IntelliJ IDEA plugin installation

Maven dependencies

Examples

Simple SQL programming without coding

Persistence

Counting and querying

Paged querying

Relation querying

Complex SQL programming

Reference documentation

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Features

Installation

IntelliJ IDEA plugin installation

Maven dependencies

Examples

Simple SQL programming without coding

Persistence

Counting and querying

Paged querying

Relation querying

Complex SQL programming

Reference documentation

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Latest commit

History

Folders and files

Repository files navigation

Features