ID Üretimi ve Batch Insert — 200 Satır Kaç Gidiş Dönüş?

1
// One settled card sale = one journal entry with two postings: debit the
2
// merchant settlement account, credit the merchant's current account.
3
@Entity
4
@Table(name = "journal_entries")
5
public class JournalEntry {
6

7
    @Id
8
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "journal_entries_seq")
9
    @SequenceGenerator(name = "journal_entries_seq", sequenceName = "journal_entries_seq", allocationSize = 50)
10
    private Long id;
11

12
    @OneToMany(mappedBy = "entry", cascade = CascadeType.PERSIST)
13
    private List<Posting> postings = new ArrayList<>();
14

15
    private String settlementRef;    // the line's reference in the scheme's file
16
    private LocalDate valueDate;
17

18
    public static JournalEntry from(SettlementLine line, String settlementAccount) {
19
        var entry = new JournalEntry();
20
        entry.settlementRef = line.ref();
21
        entry.valueDate = line.valueDate();
22
        entry.add(Posting.debit(settlementAccount, line.netAmount()));
23
        entry.add(Posting.credit(line.merchantIban(), line.netAmount()));
24
        return entry;
25
    }
26

27
    private void add(Posting posting) {
28
        postings.add(posting);
29
        posting.attachTo(this);
30
    }
31
}
32

33
@Entity
34
@Table(name = "postings")
35
class Posting {
36

37
    @Id
38
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "postings_seq")
39
    @SequenceGenerator(name = "postings_seq", sequenceName = "postings_seq", allocationSize = 50)
40
    private Long id;
41

42
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
43
    private JournalEntry entry;
44

45
    private String account;
46
    private BigDecimal debit;
47
    private BigDecimal credit;
48

49
    protected Posting() {}
50

51
    static Posting debit(String account, BigDecimal amount) {
52
        var p = new Posting();
53
        p.account = account;
54
        p.debit = amount;
55
        p.credit = BigDecimal.ZERO;
56
        return p;
57
    }
58

59
    static Posting credit(String account, BigDecimal amount) {
60
        var p = new Posting();
61
        p.account = account;
62
        p.debit = BigDecimal.ZERO;
63
        p.credit = amount;
64
        return p;
65
    }
66

67
    void attachTo(JournalEntry entry) {
68
        this.entry = entry;
69
    }
70
}

1
-- INCREMENT BY must equal allocationSize (50). The pooled optimizer treats each
2
-- nextval as the end of a 50-id block; with INCREMENT BY 1, blocks would overlap.
3
CREATE SEQUENCE journal_entries_seq START WITH 1 INCREMENT BY 50;
4
CREATE SEQUENCE postings_seq        START WITH 1 INCREMENT BY 50;

1
@Service
2
class SettlementImport {
3

4
    private static final int BATCH = 50;   // keep in step with hibernate.jdbc.batch_size
5

6
    private final String settlementAccount;
7

8
    @PersistenceContext
9
    private EntityManager em;
10

11
    SettlementImport(@Value("${ledger.pos-settlement-account}") String settlementAccount) {
12
        this.settlementAccount = settlementAccount;
13
    }
14

15
    // One transaction for the whole file: the file is either fully posted or not at all,
16
    // so reconciliation never has to deal with half a night's settlement.
17
    @Transactional
18
    public int importFile(List<SettlementLine> lines) {
19
        for (int i = 0; i < lines.size(); i++) {
20
            em.persist(JournalEntry.from(lines.get(i), settlementAccount));   // cascade persists both postings
21
            if ((i + 1) % BATCH == 0) {
22
                em.flush();    // send the batched INSERTs
23
                em.clear();    // and forget the entities: memory stays flat
24
            }
25
        }
26
        return lines.size();
27
    }
28
}

1
spring:
2
  datasource:
3
    # PostgreSQL driver: turn a JDBC batch into one multi-row INSERT statement.
4
    url: jdbc:postgresql://db:5432/ledger?reWriteBatchedInserts=true
5
  jpa:
6
    properties:
7
      hibernate:
8
        jdbc:
9
          batch_size: 50       # unset by default: no batching at all
10
        order_inserts: true    # group entry/posting/entry/posting into entry…entry, posting…posting
11
        order_updates: true
12

13
ledger:
14
  pos-settlement-account: "TR000000000000000000000001"   # internal clearing account, placeholder

1
// The mobile app generates the id before sending (a UUIDv7 keeps index inserts
2
// ordered) and reuses it on retry, so a double tap cannot create two payments.
3
// Spring Data would call merge() for a non-null id and SELECT before every INSERT;
4
// Persistable tells it the entity is new.
5
@Entity
6
public class PaymentInstruction implements Persistable<UUID> {
7

8
    @Id
9
    private UUID id;
10

11
    private String toIban;
12
    private BigDecimal amount;
13

14
    @Transient
15
    private boolean isNew = true;
16

17
    protected PaymentInstruction() {}
18

19
    public PaymentInstruction(UUID id, String toIban, BigDecimal amount) {
20
        this.id = id;
21
        this.toIban = toIban;
22
        this.amount = amount;
23
    }
24

25
    @Override public UUID getId() { return id; }
26
    @Override public boolean isNew() { return isNew; }
27

28
    @PostLoad @PostPersist
29
    void markNotNew() {
30
        this.isNew = false;
31
    }
32
}