chuigda / project-rela

Translate relational queries to some imperative codes

project-rela

Deprecated

project-rela's Issues

The indexing API is so limited that impossible to implement ranged scanning with

The current indexing implementation, svec or sorted vector, is capable of ranged scanning. However, the indexing API looks like this:

(define (rl-iter-indexable? iter indexed-field)
  (let* ([iter-indexable-check (rl-iter-procs-indexable-check iter)])
    (and (not-null? iter-indexable-check)
         (iter-indexable-check indexed-field))))

(define (rl-iter-index iter column-name)
  (let* ([procs (rl-iter-procset iter)]
         [index (rl-iter-procs-index procs)])
    (index column-name)))

We need soem new API, to support the need of ranged scanning.

store more data in procedures

in essence, since we are using Racket, we should store more data into procedures, instead of extracting them from input parameters. for example:

 219 (define (rl-build-basic-iter table)                                                                                                              
 220   (define (rl-basic-iter-get basic-iter)                                                                                                         
 221     (let ([cur-tuples (rl-basic-iter-cur-tuples basic-iter)])                                                                                    
 222       (cond [(rl-phantom-tuple? cur-tuples) (error "iterator not ready")]                                                                        
 223             [(null? cur-tuples) (error "iterator at end")]                                                                                       
 224             [else (car cur-tuples)])))
; ...
 237   (define (rl-basic-iter-name basic-iter)                                                                                                        
 238     (let ([table (rl-basic-iter-table basic-iter)])                                                                                              
 239       (rl-table-name table)))                                                                                                                    
 240   (define (rl-basic-iter-columns basic-iter)                                                                                                     
 241     (let ([table (rl-basic-iter-table basic-iter)])                                                                                              
 242       (rl-table-columns table)))  

Since the iterator and the procedures are always bundled together, the rl-basic-iter-name could simply rely on the outter table, instead of extracting the table information from basic-iter. So does rl-basic-iter-columns. We should re-design our API.

Rewrite OOP part with message passing style.

The current OOP implementation is in essence emulating C++ vtable, which results in long boilerplate code. Use the message passing style you learnt from SICP 2.5.

Structural testing

The current testing requires human observations. I'd be appreciate if someone can make it structural.

Indexed scanning with ordered index

currently we implement the ordered index as a binary tree, which makes it uneasy to work with our current iterator API, since iterating a binary tree requires bunches of bookkeeping informations.

Optimized compiler

We need an optimized compiler in order to make full use of the rl-ranged-iter and rl-equiv-join-iter.