scalable trigger processing eric n hanson et al n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Scalable Trigger Processing* - Eric N. Hanson et al. PowerPoint Presentation
Download Presentation
Scalable Trigger Processing* - Eric N. Hanson et al.

Loading in 2 Seconds...

play fullscreen
1 / 20

Scalable Trigger Processing* - Eric N. Hanson et al. - PowerPoint PPT Presentation


  • 51 Views
  • Uploaded on

Scalable Trigger Processing* - Eric N. Hanson et al. CSCi8701: Overview of Database Research Paper Presentation Group 4: Betsy George, Vijay Gandhi. *International Conference on Data Engineering, 1999. Presentation Outline. Motivation Problem Definition Related Work Contributions

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Scalable Trigger Processing* - Eric N. Hanson et al.' - rollin


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
scalable trigger processing eric n hanson et al

Scalable Trigger Processing* -Eric N. Hanson et al.

CSCi8701: Overview of Database Research

Paper Presentation

Group 4: Betsy George, Vijay Gandhi

*International Conference on Data Engineering, 1999

presentation outline
Presentation Outline
  • Motivation
  • Problem Definition
  • Related Work
  • Contributions
  • Key Concepts
  • Validation
  • Future Work
  • Rewrite Today
  • Summary
motivation
Motivation
  • Traditional uses of Triggers
    • Constraint checking
    • Logging
    • Replication
  • Web-based applications
    • Create triggers interactively
      • E.g. Stock Ticker notification:
        • If share value of Google goes down below 500

notify a person

  • Limitations of current trigger systems
    • Not scalable
problem definition
Problem Definition
  • Given: A Relational DBMS, Trigger statements, Data Stream (tokens)
  • Find: Triggers corresponding to each token
  • Objective: Scalable trigger processing system
  • Constraints:
    • Number of distinct structures of trigger expressions is small
    • All distinct structures of trigger expressions should be small enough to fit in the main memory
related work
Related Work

ECA Model

(not scalable)

Indexing

Parallel Processing

[Gupt89,Hell98]

AI

[Forg82,Mira87]

(smaller rule set)

Range Predicates, Marking based

[Hans96b, Ston90]

(large memory, complicated storage)

The work proposed here is a combination of improvised version of some

of the modules mentioned above.

contribution
Contribution
  • Data Structures
    • If a large number of triggers are created, many of them have almost the same format
    • Predicate Index Structure
    • Most important contribution
  • Concurrent processing
    • Identified 4 levels of concurrency
    • Implemented token-level concurrency
key concepts trigger structure
Key Concepts – Trigger Structure
  • Example: Stock ticker notification
  • Create triggerT1fromstock

whenstock.ticker = ‘GOOG’ and stock.value < 500

donotify_person(P1)

  • Create triggerT2fromstock

whenstock.ticker = ‘MSFT’ and stock.value < 30

donotify_person(P2)

  • Create triggerT3fromstock

whenstock.ticker = ‘ORCL’ and stock.value < 20

donotify_person(P3)

  • Create triggerT4 from stock

whenstock.ticker = ‘GOOG’

donotify_person(P4)

key concepts expression signature
Key Concepts – Expression Signature
  • Common structures in the condition of triggers
    • Expression Signature:
      • E1: stock.ticker = const1 and stock.value < const2
    • Expression Signature:
      • E2: stock.ticker = const3

T1: stock.ticker = ‘GOOG’ and stock.value < 500

T2: stock.ticker = ‘MSFT’ and stock.value < 30

T3: stock.ticker = ‘ORCL’ and stock.value < 20

T4: stock.ticker = ‘GOOG’

key concepts a treat network

Root

stock.value < const2

stock.ticker = const1

predicates

Node 1

Node 2

alpha-node

alpha-node

Key Concepts – A-Treat Network
  • For each trigger condition
  • stock.ticker = const1 and stock.value < const2
key concepts expression signature1
Key Concepts – Expression Signature
  • Expression Signature Table

E1: stock.ticker = const1 and stock.value < const2

E2: stock.ticker = const3

key concepts constant table
Key Concepts – Constant Table
  • Tables to include constants occurring in the condition of triggers
  • const_e1

Const_e2

T1: stock.ticker = ‘GOOG’ and stock.value < 500

T2: stock.ticker = ‘MSFT’ and stock.value < 30

T3: stock.ticker = ‘ORCL’ and stock.value < 20

T4: stock.ticker = ‘GOOG’

key concepts summary
Key Concepts – Summary
  • Expression Signature
    • Common structure in a trigger
      • E1: stock.ticker = const1 and stock.value < const2
  • A-treat network
    • Network for trigger condition testing
      • For a Trigger to fire, all conditions must be true
  • Constant Tables
    • Constants for each Expressions Signature
key concepts processing
Key Concepts - Processing

Update Stock(ticker=GOOG,value=495)

Root

Index of

stock.ticker=const1

Other source

Predicate index…

E1: stock.ticker = const1 and stock.value < const2

E1

E2

const_e1

const_e2

const_e1

concurrency
Concurrency
  • Concurrency
    • Better scalability
    • Even on single processor
  • Identified elements that can be parallelized
    • Token-level
      • Multiple tokens processed in parallel
    • Condition-level
      • Multiple selection conditions tested concurrently
    • Rule-action-level
      • Multiple rule actions fired at the same time
    • Data-level
      • Set of data values in the network processed in parallel
  • Implemented Token-level concurrency
validation
Validation
  • Important fact: If a large number of triggers are created, many of them have almost the same format
  • Implemented as an Informix DataBlade
  • No experimental comparisons
assumptions
Assumptions
  • If a large number of triggers are created, many of them have almost the same format
  • All distinct predicate structures fit into the main memory
rewrite today
Rewrite today
  • Validations
    • Provide Experimental Comparisons
    • Test on real datasets
  • Examples: Execution Trace
  • Remove sections on TriggerMan Command Language and Architecture
  • Describe A-TREAT network
summary
Summary
  • If a large number of triggers are created, many of them have almost the same format
  • Number of distinct signatures is small enough to fit into the main memory