I'm not so acquainted with databases and the things they offer outdoors from the CRUD procedures.

My studies have brought me to triggers. Essentially it appears like triggers offer this kind of functionality:

(from Wikipedia)

You will find typically three triggering occasions that create triggers to 'fire':

  • Place event (like a new record has been placed in to the database).
  • UPDATE event (like a record has been transformed).
  • Remove event (like a record has been erased).

My real question is: Can there be a way I'm able to be informed in Java (ideally such as the data that transformed) through the database whenever a record is Up-to-date/Erased/Placed with a couple kind of Trigger semantics?

What may be some alternate methods to this issue? How do i pay attention to database occasions?

The primary reason I do is really a scenario such as this:

I've 5 client programs all in various processes/existing across different Computers. All of them share a typical database (Postgres within this situation).

Allows say one client changes an archive within the DB that 5 from the customers are "interested" in. I'm attempting to think about methods of the clients to become "informed" from the change (ideally using the affected data attached) rather than them querying for that data at some interval.

Using Oracle you are able to setup a Trigger on the table after which possess the trigger send a JMS message. Oracle has two different JMS implementations. After that you can possess a procedure that will 'listen' for that message while using JDBC Driver. I have tried personally this process to push changes to my application versus. polling. If you work with a Java database (H2) you've additional options. During my current application (SIEM) I've triggers in H2 that publish change occasions using JMX.

Don't combine the database (which consists of the information), and occasions on that data.

Triggers is one way, but normally you'll have a persistence layer inside your application. This layer can pick to fireplace off occasions when some things happen - tell a JMS subject.

Triggers really are a last ditch factor, as you are operating on relational products then, instead of "occasions" around the data. (For instance, an "update", could the truth is map to some "company transformed legal title" event) Should you depend around the db, you will need to map the card inserts &lifier updates to real existence occasions.... that you simply already understood about!

After that you can layer other things on the top of those notices - like event stream processing - to locate occasions that others are curious about.


Calling exterior processes in the database is extremely vendor specific.

Just off the top my mind:

  • SQLServer can call CLR programs from triggers,

  • postgresql can call arbitrary C functions loaded dynamically,

  • MySQL can call arbitrary C functions, but they ought to be put together in,

  • Sybase could make system calls if set up to do this.

The easiest factor to complete is to achieve the place/update/remove triggers make an entry in certain log table, and also have your java program monitor that table. Good posts to possess inside your log table could be such things as EVENT_CODE, LOG_DATETIME, and LOG_Monosodium glutamate.

Unless of course you need high performance or have to handle 100Ks of records, that's most likely sufficient.

Hmm. So you are using PostgreSQL and you need to "listen" for occasions and become "informed" once they occur?

http://www.postgresql.org/paperwork/8.3/static/sql-listen.html http://www.postgresql.org/paperwork/8.3/static/sql-inform.html

Hope this can help!

What you are asking completely is dependent on the database you are using and also the framework you are using to talk with your database.

If you are using something similar to Hibernate as the persistence layer, it features a group of audience and interceptors which you can use to watch records going interior and exterior the database.