DEV Community: Braisdom

ObjectiveSQL Performance

Braisdom — Thu, 24 Dec 2020 08:15:38 +0000

Benchmark               (framework)   Mode  Cnt    Score    Error   Units
BenchmarkRunner.query       mybatis  thrpt   10   66.269 ±  5.584  ops/ms
BenchmarkRunner.query          jdbc  thrpt   10  125.223 ±  6.476  ops/ms
BenchmarkRunner.query     hibernate  thrpt   10   57.952 ±  2.983  ops/ms
BenchmarkRunner.query        objsql  thrpt   10   85.329 ±  4.812  ops/ms
BenchmarkRunner.update      mybatis  thrpt   10  118.780 ±  6.028  ops/ms
BenchmarkRunner.update         jdbc  thrpt   10  184.414 ± 10.612  ops/ms
BenchmarkRunner.update    hibernate  thrpt   10   66.626 ±  1.556  ops/ms
BenchmarkRunner.update       objsql  thrpt   10  130.013 ±  2.718  ops/ms

The Challenge of the ORM in Java(Simple querying)

Braisdom — Fri, 11 Dec 2020 13:47:32 +0000

The ObjectiveSQL is a new ORM framework, it enhances the existed ORM framework capability, the first is simple querying.

Definition of domain model

@DomainModel
public class Blog {
    private Long id;
    private String title;
    private Integer state;

    @Relation(relationType = RelationType.BELONGS_TO)
    private Author author;
}

In MyBatis:

<mapper>
  <resultMap type="Blog" id="blog">
    <id column="id" property="id" />
    ...
    <association property="author" javaType="Author">
      ...
    </association>
  </resultMap>
  <select id="findBlog" parameterType="int" resultMap="blog">
    ...
  </select>
</mapper>

...
BlogMapper mapper = session.getMapper(BlogMapper.class); 
Blog blog = mapper. findBlog(...);

In ObjectiveSQL:

Blog blog = Blog.queryByPrimaryKey(1, Blog.BELONGS_TO_AUTHOR);

https://github.com/braisdom/ObjectiveSql

Complex SQL programming in Java

Braisdom — Wed, 09 Dec 2020 09:50:36 +0000

Java and SQL have come a long way. SQL is an "old", yet established and well-understood technology. Java is a legacy too, although its platform JVM allows for many new and contemporary languages built on top of it. Yet, after all these years, libraries dealing with the interface between SQL and Java have come and gone, leaving JPA to be a standard that is accepted only with doubts, short of any surviving options.
ObjectiveSQL has come to fill this gap.

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) with Java syntax

Java codes:

// SQL programming with Java syntax without losing the features of SQL syntax
Order.Table orderTable = Order.asTable();
Select select = new Select();

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 generated:

-- SQL syntax is the same as Java syntax
SELECT ((((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`

Lombok can be as ORM framework

Braisdom — Sat, 05 Dec 2020 13:02:10 +0000

Do you like Lombok? Ohh! You might think it changed the way Java programming, but it makes your programming efficient.

Now, It can become an ORM framework, Improve your efficiency in SQL programming.

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.

Github

https://github.com/braisdom/ObjectiveSql

Features

With one annotation your Class has fully featured capabilities of SQL programming
Easy to relational(has_one, has_many, beglongs_to) querying and paged querying
Java expressions(arithmetic, comparison and logical) can be converted into SQL expression directly

Simple SQL programming without coding

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

@DomainModel
public class Member {
    private String no;

    @Queryable
    private String name;
    private Integer gender;
    private String mobile;
    private String otherInfo;

    @Relation(relationType = RelationType.HAS_MANY)
    private List<Order> orders;
}

Querying

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

Relation querying

Member.queryAll(Member.HAS_MANY_ORDERS);
Member.queryByPrimary(1, Member.HAS_MANY_ORDERS);
Member.queryByName("demo", Member.HAS_MANY_ORDERS);

A new ORM framework in Java

Braisdom — Fri, 27 Nov 2020 13:24:32 +0000

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.

github: https://github.com/braisdom/ObjectiveSql

Features

Dynamic code generation with JSR 269 for Java API of database access
Automate your methods of CRUD operations in database, and much more
Easy to relation query, transaction and paged query
Dynamically SQL programming with Java syntax, and similar to program with SQL syntax extremely

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.0</version>
</dependency>

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

Refer to the pom.xml for more configurations

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.

MySQL, Oracle, MS SQL Server, SQLite, PostgreSQL, Spring Boot

Simple SQL programming without coding

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

@DomainModel
public class Member {
    private String no;

    @Queryable
    private String name;
    private Integer gender;
    private String mobile;
    private String otherInfo;

    @Relation(relationType = RelationType.HAS_MANY)
    private List<Order> orders;
}

Persistence methods

Member.create(newMember);
Member.create(newMember, true); // Create a member without validating
Member.create(Member.newInstanceFrom(memberHash));
Member.create(new Member[]{newMember1, newMember2, newMember3}, false);

Member.update(1L, newMember, true); // Update a member with primary key
Member.update("name = 'Smith => Jackson'", "name = 'Alice'");

Member.destroy(1L); // Delete a member with primary key
Member.destroy("name = 'Mary'");

// Execute SQL
Member.execute(String.format("DELETE FROM %s WHERE name = 'Mary'", Member.TABLE_NAME));

Transaction

@Transactional
public static void makeOrder(Order order, OrderLine... orderLines) throws SQLException {
  Order.create(order, false);
  OrderLine.create(orderLines, false);
}

Counting and querying simply

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

Paged query

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

Relation query

// Querying objects with convenient methods, and it will carry the related objects
Member.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 syntax
Order.Table orderTable = Order.asTable();
Select select = new Select();

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 syntax
SELECT ((((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`

See more:

A new way of ORM in Java (ObjectiveSQL)

Braisdom — Sat, 21 Nov 2020 15:09:30 +0000

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

Features
1) Dynamic code generation with JSR 269 for Java API of database access
2) Full Java API of database access without coding
3) Dynamically SQL programming with Java syntax, and very close to SQL syntax

See more: https://github.com/braisdom/ObjectiveSql

We are proud to announce ObjectiveSQL is released

Braisdom — Tue, 06 Oct 2020 11:44:52 +0000

In Java, there is not excellent ORM framework, likes ActiveRecord of Rails, today, the ObjectiveSQL appeared, no configuration, no no-implementational Interface, generates the codes automatically.
You can see more: https://github.com/braisdom/ObjectiveSql