Changeset 436

Show
Ignore:
Timestamp:
01/31/05 18:34:04 (4 years ago)
Author:
torben
Message:

The Plucene Interface is complete and works generally. No Warning/Error
conditions are caught yet, due to a lack of documentation where what
could be caught where.

Basic tests work, a few Plucene limitations are worked-around, and you can
test it using this basic code:

--cut--
#!/usr/bin/perl

use strict;
use warnings;

use IO::Handle;
use Midcom::Plucene::RequestProcessor?;

my $in = IO::Handle->new_from_fd(fileno(STDIN), "r");
my $out = IO::Handle->new_from_fd(fileno(STDOUT), "w");

my $proc = Midcom::Plucene::RequestProcessor?->new($in, $out);

$proc->Process();
--cut--

Note, that the XML specs in the web are not 100% accurate at this time,
a few changes are only in the DTD yet, I will update this tomorrow.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/external-tools/indexer-backends/plucene/Midcom/Indexer/XMLComm.pm

    r435 r436  
    4545        my $self = {}; 
    4646 
    47         $self->{requests} = []; 
    48         $self->{responses} = []; 
    49         $self->{indexname} = undef; 
    50  
    51         $self->{parser} = XML::LibXML->new(); 
    52         $self->{parser}->validation(1); 
    53         $self->{parser}->keep_blanks(0); 
    54  
    55         $self->{document} = undef; 
     47        $self->{_requests} = []; 
     48        $self->{_indexname} = undef; 
     49 
     50        $self->{_parser} = XML::LibXML->new(); 
     51        $self->{_parser}->validation(1); 
     52        $self->{_parser}->keep_blanks(0); 
     53 
     54        $self->{_in} = shift; 
     55        $self->{_out} = shift; 
     56        $self->{_processor} = shift; 
     57 
     58        $self->{_output} = new XML::Writer( 
     59                OUTPUT => $self->{_out}, 
     60                DATA_MODE => 1, 
     61                DATA_INDENT => 1 
     62        ); 
     63 
     64        $self->{_document} = undef; 
    5665 
    5766        bless ($self, $class); 
    …… 
    5968} 
    6069 
     70########### 
     71# Accessors 
     72 
     73sub output 
     74{ 
     75        my $self = shift; 
     76        return $self->{_output}; 
     77} 
     78 
     79sub processor 
     80{ 
     81        my $self = shift; 
     82        return $self->{_processor}; 
     83} 
     84 
     85sub indexName 
     86{ 
     87        my $self = shift; 
     88        return $self->{_indexname}; 
     89} 
     90 
     91sub requests 
     92{ 
     93        my $self = shift; 
     94        return $self->{_requests}; 
     95} 
    6196 
    6297 
    …… 
    68103sub ParseRequest 
    69104{ 
    70         my ($self, $data) = @_; 
    71          
    72         $self->{document} = $self->{parser}->parse_string($data); 
    73  
    74         my $root = $self->{document}->documentElement(); 
    75         $self->{indexname} = $root->getAttribute('index'); 
     105        my $self = shift; 
     106 
     107        # Initialize output XML file 
     108         
     109        $self->{_output}->xmlDecl('UTF-8'); 
     110        $self->{_output}->doctype('response', undef, 'xml-communication-response.dtd'); 
     111        $self->{_output}->startTag('response'); 
     112 
     113         
     114        # Parse input XML file 
     115         
     116        $self->{_document} = $self->{_parser}->parse_fh($self->{_in}); 
     117 
     118        my $root = $self->{_document}->documentElement(); 
     119        $self->{_indexname} = $root->getAttribute('index'); 
    76120         
    77121        my @childs = $root->childNodes; 
    78122        foreach my $node (@childs) 
    79123        { 
     124                # Check only nodes, skip all other stuff like comments 
     125                if ($node->nodeType != 1) 
     126                { 
     127                        next; 
     128                } 
     129                 
    80130                # Parse node type, relay to corresponding handler 
    81131                if ($node->nodeName eq 'query') 
    …… 
    99149                else 
    100150                { 
    101                         die ("The Request type $node->nodeName is unknown to this handler."); 
     151                        die ("The Request type $node ( " . $node->nodeName . ") is unknown to this handler."); 
    102152                        # Should we throw an error here? 
    103153                } 
    104154        } 
     155 
     156 
     157        # Finish output XML file 
     158         
     159        $self->{_output}->endTag('response'); 
     160        $self->{_output}->end(); 
    105161} 
    106162 
    …… 
    153209        } 
    154210         
    155         $request->dump; 
    156         push @{$self->{requests}}, $request; 
     211        # $request->dump; 
     212        $request->execute(); 
     213        push @{$self->{_requests}}, $request; 
    157214} 
    158215 
    …… 
    167224        $request->documentID($node->getAttribute('documentid')); 
    168225 
    169         $request->dump; 
    170         push @{$self->{requests}}, $request; 
     226        # $request->dump; 
     227        $request->execute(); 
     228        push @{$self->{_requests}}, $request; 
    171229} 
    172230 
    …… 
    219277                } 
    220278                 
    221                 $request->dump; 
    222                 push @{$self->{requests}}, $request; 
     279                # $request->dump; 
     280                $request->execute(); 
     281                push @{$self->{_requests}}, $request; 
    223282 
    224283                # Go to the next document 
    225284                $document_node = $document_node->nextSibling(); 
    226285        } 
    227          
    228286} 
    229287 

  • trunk/external-tools/indexer-backends/plucene/Midcom/Plucene/BaseRequest.pm

    r435 r436  
    88use warnings; 
    99 
    10 use Plucene::Index::Term; 
    1110use Time::Piece; 
    1211 
    …… 
    4544 
    4645        $self->{_XMLComm} = shift; 
     46        $self->{_processor} = $self->{_XMLComm}->processor; 
    4747        $self->{_id} = undef; 
    4848        $self->{_type} = undef; 
    …… 
    9393# Execute Handler 
    9494 
    95 sub execute { }; 
     95sub execute { } 
    9696 
    9797 

  • trunk/external-tools/indexer-backends/plucene/Midcom/Plucene/DeleteRequest.pm

    r435 r436  
    1010use Midcom::Plucene::BaseRequest; 
    1111use Plucene::Index::Term; 
    12 use Time::Piece; 
    1312 
    1413 
    …… 
    4746{ 
    4847        my $class = shift; 
    49         my $self = $class->SUPER::new(); 
     48        my $self = $class->SUPER::new(@_); 
    5049         
    5150        $self->type('delete'); 
    …… 
    7473sub execute 
    7574{ 
    76         my ($self, $reader) = @_; 
     75        my $self = shift; 
    7776 
    7877        my $term = Plucene::Index::Term->new( 
    …… 
    8281                } 
    8382        ); 
    84         $reader->delete_term($term); 
     83        $self->{_processor}->indexReader->delete_term($term); 
     84         
     85        # Tag the Writer object, so that it gets loaded from the request 
     86        # processor. This is will optimize the database after completing 
     87        # the current batch thus dropping all unused references to the 
     88        # deleted documents. I hate it. 
     89        $self->{_processor}->indexWriter(); 
    8590} 
    8691 

  • trunk/external-tools/indexer-backends/plucene/Midcom/Plucene/IndexRequest.pm

    r435 r436  
    1212use Plucene::Document::Field; 
    1313use Plucene::Document::DateSerializer; 
    14 use Time::Piece; 
    1514 
    1615 
    …… 
    5049{ 
    5150        my $class = shift; 
    52         my $self = $class->SUPER::new(); 
     51        my $self = $class->SUPER::new(@_); 
    5352 
    5453        $self->type('index'); 
    …… 
    7776{ 
    7877        my ($self, $name, $contents) = @_; 
    79         $self->{_document}->add(Plucene::Document::Field->Keyword($name, $self->mkDate($contents))); 
     78        $self->{_document}->add(Plucene::Document::Field->Keyword($name, freeze_date($self->mkDate($contents)))); 
    8079} 
    8180 
    …… 
    116115sub execute 
    117116{ 
    118         my ($self, $writer) = @_; 
    119         $self->add_keyword('__RI', $self->{_documentID}); 
    120         $writer->add_document($self->{_document}); 
     117        my $self = shift; 
     118        $self->addKeyword('__RI', $self->{_documentID}); 
     119        $self->{_processor}->indexWriter->add_document($self->{_document}); 
    121120} 
    122121 

  • trunk/external-tools/indexer-backends/plucene/Midcom/Plucene/QueryRequest.pm

    r435 r436  
    1111use Plucene::Document::DateSerializer; 
    1212use Plucene::Search::DateFilter; 
    13 use Time::Piece; 
    1413 
    1514 
    …… 
    4948{ 
    5049        my $class = shift; 
    51         my $self = $class->SUPER::new(); 
     50        my $self = $class->SUPER::new(@_); 
    5251 
    5352        $self->type('query'); 
    …… 
    101100sub execute 
    102101{ 
    103         my ($self, $parser, $searcher) = @_; 
     102        my $self = shift; 
    104103 
    105         my $query = $parser->parse($self->{_queryString}); 
     104        my $query = $self->{_processor}->queryParser->parse($self->{_queryString}); 
    106105        my $hits; 
    107106         
    108107        if ($self->{_dateFilterFrom} || $self->{_dateFilterTo}) 
    109108        { 
    110                 my $filter = Plucene::Search::DateFilter->new( 
    111                         { 
    112                                 field => $self->{_dateFilterField}, 
    113                                 from => $self->{_dateFilterFrom}, 
    114                                 to => $self->{_dateFilterTo} 
    115                         } 
     109                my $filter_config = {}; 
     110                 
     111                $filter_config->{field} = $self->{_dateFilterField}; 
     112                if ($self->{_dateFilterFrom}) 
     113                { 
     114                        $filter_config->{from} = $self->{_dateFilterFrom}; 
     115                } 
     116                if ($self->{_dateFilterFrom}) 
     117                { 
     118                        $filter_config->{from} = $self->{_dateFilterFrom}; 
     119                } 
     120                 
     121                $hits = $self->{_processor}->indexSearcher->search( 
     122                        $query,  
     123                        Plucene::Search::DateFilter->new($filter_config) 
    116124                ); 
    117                 $hits = $searcher->search($query, $filter); 
    118125        }        
    119126        else 
    120127        { 
    121                 $hits = $searcher->search($query); 
     128                $hits = $self->{_processor}->indexSearcher->search($query); 
    122129        } 
    123130 
    124         print "\nWe found " . $hits->length . " documents:\n\n"; 
    125         for (my $i = 0; $i < $hits->length; $i++) 
     131        my $output = $self->{_XMLComm}->output; 
     132 
     133        $output->startTag('resultset', 'id' => $self->id()); 
     134         
     135        # Build a sorted resultset (take the indices directly, order them, then go ahead) 
     136        my @order = sort  
     137                {  
     138                        $hits->score($b) <=> $hits->score($a)  
     139                }  
     140                (0..($hits->length-1)); 
     141         
     142        foreach my $i (@order) 
    126143        { 
    127                 # my $doc = $hits->doc($i); 
    128                 print "\nDocument $i:\n"; 
    129                 print "Score:\t" . $hits->score($i) . "\n"; 
     144                my $doc = $hits->doc($i); 
     145                my $score = $hits->score($i); 
     146                my $id = $doc->get('__RI')->string; 
     147 
     148                $output->startTag('document', 
     149                        'id' => $id, 
     150                        'score' => $score); 
     151                 
     152                foreach my $field ($doc->fields) 
     153                { 
     154                        $output->cdataElement('field', $field->string, 'name' => $field->name); 
     155                } 
     156                 
     157                $output->endTag('document'); 
    130158        } 
     159 
     160        $output->endTag('resultset'); 
    131161} 
    132162