DBIx::Class::Indexed - Index data via external indexing facilities.

    package Foo;

    use base qw( DBIx::Class );

    __PACKAGE__->load_components( qw( Indexed Core ) );
    __PACKAGE__->set_indexer( 'WebService::Lucene', {
        server => 'http://localhost:8080/lucene/',
        index  => 'stuff',
    });

    __PACKAGE__->add_columns(
        foo_id => {
            data_type         => 'integer',
            is_auto_increment => 1,
        },
        name => {
            data_type => 'varchar',
            size      => 256,
            indexed   => 1,
        },
        description => {
            data_type => 'text',
            indexed  => 1,
        },
    );

package DBIx::Class::Indexed;

use strict;
use warnings;

use base qw( DBIx::Class );

our $VERSION = '0.02';

__PACKAGE__->mk_classdata( _indexer                => undef );
__PACKAGE__->mk_classdata( indexer_connection_info => {} );
__PACKAGE__->mk_classdata( indexer_package         => undef );
__PACKAGE__->mk_classdata( index_fields            => {} );
__PACKAGE__->mk_classdata( index_on_insert         => 1 );
__PACKAGE__->mk_classdata( index_on_update         => 1 );
__PACKAGE__->mk_classdata( index_on_delete         => 1 );

sub indexer {
    my $self    = shift;
    my $schema  = $self->result_source->schema;
    my $key     = $self->indexer_connection_info->{ storage_key } || $self->table;

    $schema->{ _indexers } = {} unless $schema->{ _indexers };     

    my $indexer = $schema->{ _indexers }->{ $key };
    
    # lazy load the indexer
    if( !$indexer ) {
        my $name    = $self->indexer_package;
        my $package = "DBIx::Class::Indexer::$name";
        
        # ensure the indexer package is loaded
        eval "require $package";
        die "Failed to load indexer: $@" if $@;

        $indexer = $package->new( $self->indexer_connection_info, ref $self );
        $schema->{ _indexers }->{ $key } = $indexer;
    }

    return $indexer;
}

sub set_indexer {
    my $class        = shift;
    my $name         = shift;
    my $connect_info = shift;
    
    $class->indexer_package( $name );
    $class->indexer_connection_info( $connect_info || {} );
}

sub insert {
    my $self   = shift;
    my $result = $self->next::method( @_ );
    
    if ( $self->index_on_insert and my $indexer = $self->indexer ) {
        $indexer->insert( $self, @_ );
        
        if ( $self->is_changed ) {
            $result = $self->next::method( @_ );
        }
    }
    
    return $result;
}

sub update {
    my $self   = shift;
    my $result = $self->next::method( @_ );
    
    if ( $self->index_on_update and my $indexer = $self->indexer ) {
        $indexer->update( $self, @_ );
        
        if ( $self->is_changed ) {
            $result = $self->next::method( @_ );
        }
    }
    
    return $result;
}

sub delete {
    my $self = shift;
    
    if ( $self->index_on_delete and my $indexer = $self->indexer ) {
        $indexer->delete( $self, @_ );
    }
    
    $self->next::method( @_ );
}

sub register_column {
    my( $class, $column, $info ) = @_;
    $class->next::method( $column, $info );
    
    if (exists $info->{ indexed }) {
        $class->register_field( $column => $info->{ indexed } );
    }
}

sub add_index_fields {
    my( $class, @fields ) = @_;
    my $fields = $class->index_fields;
    
    while ( my $field = shift @fields ) {
        # If next entry is { ... } use that for the column info, if not
        # use an empty hashref
        my $field_info = ref $fields[ 0 ] ? shift @fields : {};
        $class->register_field( $field, $field_info );
    }
}

sub register_field {
    my( $class, $field, $info ) = @_;
    $class->index_fields->{ $field } = $info;
}

1;