BE Study 8th

 Let's take a look at JPA through looking into Post.java


@Entity

@Table(name = "posts")

@Entity is an annotation that enables the following class to be mapped with a table of DB. @Table is an annotation that designates which table the entity will be mapped to. It has parameters like 

name: designates the name of the table to which entity will be mapped, uses entity's name if not given.

catalog: map catalog

schema: map schema

uniqueContraints: generate unique constraints if use DDL


public class Post {
defines the class

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "post_id_generator")
    @SequenceGenerator(name = "post_id_generator", sequenceName = "post_id_seq", allocationSize = 5)
@Id means that the following attribute will be the primary key of the table. @GeneratedValue is the value that uses other strategies to define primary key like

strategy = GenerationType.IDENTITY: this uses 'AUTO_INCREMENT' of mySQL and uses it as PK.
@GeneratedValue(strategy = GenerationType. SEQUENCE, generator = ' '): uses SEQUENCE of Oracle using generator. It Requires @SequenceGenerator to be used.
@GeneratedValue(strategy = GenerationType.TABLE, generator = ' '): uses TABLE using generator. It requires @TableGenerator to be used.

@SequenceGenerator is used to create a generator for @GeneratedValue. It has parameters like
 name: name of the sequence generator
sequenceName: sequence name of the DB
initialValue: used when generating DDL. Defines the first value when generating DDL.
allocation Size: incremented size per a sequence call.
catalog: DB's catalog
schema: DB's schema

    @Column(nullable = false)
    @NotEmpty
    private String title;
@Column means the attribute becomes a column of the table. It has parameters like

name: designates the name of the column to which attribute will be mapped
insertable: saves field when you save the entity
updatable: modifies fiedl when you modify the entity
tabel: designates the name of the table to which attribute will be mapped. Used when you map into more than two tables.
nullable: able to nullify the table
unique: grants unique Constraints to the attribute
columnDefinition: Grants column info to the DB
length, precision, scale: Regulates the field like string length, decimal point...

@NotEmpty means that the attribute cannot be NULL or ""

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "cat_id")
    private Category category;
@ManyToOne is an annotation used to state relationship between different tables. In this case, ManyToOne means that many different posts can have same category. fetch = FetchType.LAZY means that it's fetchtype is lazy loading. Let's look into it later.

@JoinColumn means that this used as foreign key for JOIN

    @PrePersist
    public void onCreate() {
        createdAt = LocalDateTime.now();
    }
@PrePersist is an annotation that is called before new entity is created. Thus, onCreate() is called every time when new entity of the 'Post' is created. To be certain, it is called just before when new entity is saved in DB.

    @PreUpdate
    public void onUpdate() {
        updatedAt = LocalDateTime.now();
    }

@PreUpdate is an annotation that is called before any entity is updated. Thus, onUpdate is called every time just before when update of any entity is completed in DB.

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "cat_id")
    private Category category;
The above code is very important and critical. So let's take a closer look at it. It means that it category and "cat_id" has a N:1 relationship and thus makes a table that has category as a primary key and "cat_id" as a foreign key. OneToMany annotations isn't used usually because it can cause some problems. Specifically, it sends an extra 'update query' due to dirty checking. Also, the entity can send to table that does not corresponds to itself.

댓글

댓글 쓰기

이 블로그의 인기 게시물

Interface of Java

 You can define(declare + initialize) variable like interface_name variable_name = new class_name() In such cases, the variable can only use method overriding the interfaces methods. Also, the language does not recognized it as the class; the language recognizes it as interface. Still, it does have member variables of the class and there are some libraries that enables the programmer to tell what class it is constructed(i.e. Reflection) Interface can be used as parameter of functions or return types of functions. When interface is a parameter, the class that implements the interface should be given to the function. When interface is a return type, it can be used for polymorphism. Also, variable of java(in case its not primitive type like int, float), it is rather closer to pointer of C++; it refers to the value, not contains value itself. The important point is that, when the class implements the interface, all of its public methods should be the interface's methods. If not, client...
자세한 내용 보기

Data Analytics Overview(OLTP vs OLAP)

You’ve likely heard about the lucrative careers of high-level Data Analysts, but have you ever wondered how they actually handle "Big Data"? Of course, they aren’t just using Microsoft Excel. To understand the technology behind it, we must first distinguish between the two primary ways we process information:  OLTP  and  OLAP . 1. OLTP OLTP (Online Transactional Processing)  is the DB used for company’s daily operations. Whenever you post on Reddit or place an order on Amazon, you are interacting with an OLTP database. It is triggered by the business's customer and handled by the backend server so that it can provide the business. Fast:  It handles millions of requests with millisecond response times. Small&Frequent:  It focuses on small, frequent transactions—usually just a few rows at a time. Write-intensive:  Its primary job is to record or update new data as it happens. 2. OLAP OLAP (Online Analytical Processing)  is the very technology we...
자세한 내용 보기

Leetcode

이미지
1. Two Sum: find a pair with specific sum   class Solution : def twoSum ( self , nums : List [ int ] , target : int ) - > List [ int ] : numMap = { } n = len ( nums ) # Build the hash table for i in range ( n ) : numMap [ nums [ i ] ] = i # Find the complement for i in range ( n ) : complement = target - nums [ i ] if complement in numMap and numMap [ complement ] != i : return [ i , numMap [ complement ] ] return [ ] # No solution found You might wonder how does the code deals with duplicates. As you can see, in the iteration of building the hash table, always the latter(with bigger index) will be saved in the hash table. In the latter iteration finding the complement, the former one(with smaller index) always goes through the iteration earlier, so the [i, numMap[complement]] can return two different indexes, carrying duplicate...
자세한 내용 보기