All posts by admin

LiveRules mapping with RDBMS

LiveRules unique way of loading the data from any Java supported Relational Database Management System (RDBMS) is as simple as doing some mapping using our web-based administrator module. Once you give the database details, LiveRules automatically connects to your database and enables you to do the mapping to your business names which can then be used within the rules when you author them.

For example, let us consider that you have a customer who has multiple address in your RDBMS. Let us look at the sample table structure below.


customer
---------
cust_id (PK)
cust_fname
cust_lname
cust_dob
cust_gender


customer_address
-----------------
cust_addr_id (PK)
cust_id (FK)
cust_addr_type (H - home, O - Office, etc)
cust_addr1
cust_addr2
cust_city
cust_state
cust_zipcode
cust_country

If you had to load these two table data through SQL for a given “customer id” and feed in a data object and then pass them to a Rules Engine is going to take a while.  It involves a lot of coding from the developer and of course, you can be worried about defects and thus cost you a lot of time and money with time and other resources.

  1. Build the customer and customer address objects
  2. Write the query and loop through and populate these objects
  3. Go to the rules engine and then configure your objects to a business name
  4. Load the objects and invoke the rules engine with the data objects
  5. Get the results

What if someone says that don’t worry about anything, just do the database to business field name mapping and pass the customer id to get the results. Is that awesome and saves you a lot of time, money and resource?

Of course they definitely save a lot of development time, maintenance time and of course use the resource time for something really productive.

This is where LiveRules makes the difference in 3 simple steps.

  1. Give the database details and do the business name mapping to each of your table columns (as needed).
  2. Author your rule using the business names that you have just created
  3. Invoke the rules engine with the customer that you like to process the rule for (by sending the value for customer id)

The savings are endless when you have more complex tables and columns. LiveRules just of the box enables the mapping and gives you a jump-start for business.

Why LiveRules is Unique in the Rules Engine Market?

There are varieties of rules engine that are available in the market.  Picking the right one for your system would be a difficult choice.  Hopefully, we could shed some lights on how we classify the rules engine at the high-level and what are the advantages and disadvantages of these solutions.  Of course, we would show you how our LiveRules stack up in these categories.

The Rules Engines are mainly classified into two categories at the high level.  They are

  1. Legacy Rules Engine
  2. Modern Rules Engine

 What is a Legacy Rules Engine?

These are the rules engines that need the user to load the data objects and feed them to the Rules engine to process them.  In the modern world, it is a very time-consuming process and most of the time, these Legacy rules engines fall well short for the modern business demand.

In Summary, the Legacy rules engines comes with

  • Needs the data to be fed as objects because they can’t load the data by themselves
  • It needs structured objects and predefined wiring to get access to the data using one of the SQL or other data loading methods
  • They don’t come with out of the box support to integrate with various data sources
  • They don’t enable support for third-party services through web services or messaging mechanisms unless there is a custom written code
  • Any change in the structure or the wiring, it takes a long shot to fix it

What is a Modern Business Rules Engine?

The modern rules engines are intelligent enough to load the data by themselves and come with out of the box support for many integration points such as web services, third-party APIs and messaging.

In Summary, the Modern business rules engine comes with

  • They can load the data from various data sources by themselves with given mapping
  • They can interact with web services, messaging systems and other third-party APIs right out of the box
  • It supports integration with NoSQL and big data systems out of the box
  • Enables web-based system for authoring, monitoring and managing the application

 Where does LiveRules fit in?

LiveRules comes with out of the box support for most of the modern-day business rules engine.

Some of the features of LiveRules are

  • The web-based system for authoring and managing the rules
  • Comes with out of the box support for Web services, messaging and third-party APIs integration
  • Comes with a simple mapping web-based user interface, which can load, and process the data for you.  The current LiveRules version (v1.0) supports for
    • Any Java Supported RDBMS
    • MongoDB (NoSQL)
    • HBase for Hadoop integration
    • JSON
    • XML
    • YOROSIS hosts and supports the Rules Engine as a service model (which takes the JSON / XML as input and sends the output as JSON / XML)
    • Comes with handy components such as Auditing, Advisor, Log Tracking, and Dashboard reporting for easy maintenance of the system

LiveRules offers much more than a modern-day business rules engine.  The time to bring the system up from scratch with LiveRules is 10 – 20 times faster than the Legacy rules engine based system.

Interested in learning more about LiveRules, please contact us for a demo.

Why LiveRules as your Rules Engine Solution?

LiveRules is built for performance and compatibility with various data sources like any java supported RDBMS, MongoDB, JSON, XML, and HBase.

How LiveRules integrates with Databases (like any RDBMS, MongoDB and HBase)?

Our unique approach with table (in RDBMS) / collection (in NoSQL) mapping allows the administrator to build your business dictionary (business terms for your corresponding table columns) in a record time.  Once the business dictionary is mapped, then you are ready to author your rules in a Web-based editor.

How it is unique?

Most of the Rules Engines makes you feed the objects with data to process the rules.  LiveRules differs from these methodologies and allows you to switch your development to a rapid development mode.

LiveRules automatically knows how to load the data from the business dictionary from various data sources that you have built and hides the complexity of loading the data manually.

Multi Data Sources Support

Since LiveRules supports various data sources like RDBMS, MongoDB (NoSQL), JSON, XML and HBase out of the box, it makes your development really easy.

Support for Administration

LiveRules comes with lot of tools for developers to check the system and manage it effectively.  Like log tracker which can be enabled on-demand for a set of input parameters, audit logging for any slow running queries, advisor for proactive advice on any missing data in the rules that you have authored, analytics for tracking the rules, events and queries and comes with dashboard reports to show execution rates, etc.

With all these tools, the developers never need to get into the system for getting the log as it can be enabled and viewed via a web console.  Along with all the other features, one can breathe easy and support the system with ease.

LiveRules Deployment Model

LiveRules can be deployed as

  • Embedded part of Java based solutions
  • Can run as a stand-alone version without a need for any specialized environment
  • Runs behind a simple RESTful web service

Also YOROSIS offers LiveRules as a Software as a Service (SaaS) model where we take the JSON / XML as input and send back JSON / XML as output.

 

The modern business rules engine

The world of technology is changing so fast and the need for business to get into the market is always a growing challenge.  The technologists are looking for options and obviously adopting various rules engine solutions to quickly enable the business policy changes to the market.

But most of the rules engine that are in the market built based on legacy based technologies and most of them doesn’t offer interoperability between various technologies and systems which is a huge need these days.

LiveRules comes into the Rules engine that comes with out of the box support for

  • Integration with various systems
  • Integration with JSON, XML, RDBMS, MongoDB, HBase, etc
  • Support for JMS and MQ Messaging
  • Support for Web service integrations
  • Can run without any specialized server needs
  • Can run as service, standalone application or embedded in a Java based applications
  • Comes with web-based user interface for authoring rules
  • Support for multilingual
  • and so on

Not only LiveRules comes with all these out of the box support for various system and technology integrations, it also supports various run time tools which helps the business, and developers on a day-to-day support operations.