fts0types.h

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 2007, 2011, Oracle and/or its affiliates. All Rights Reserved.

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA

*****************************************************************************/

/******************************************************************/
#ifndef INNOBASE_FTS0TYPES_H
#define INNOBASE_FTS0TYPES_H

#include "que0types.h"
#include "ut0byte.h"
#include "fut0fut.h"
#include "ut0rbt.h"
#include "fts0fts.h"

struct fts_que_t;
struct fts_node_t;
struct fts_utf8_str_t;

typedef pars_user_func_cb_t fts_sql_callback;
typedef void (*fts_filter)(void*, fts_node_t*, void*, ulint len);

struct fts_doc_stats_t {
        doc_id_t        doc_id;         
        ulint           word_count;     
};

struct fts_get_doc_t {
        fts_index_cache_t*
                        index_cache;    
        que_t*          get_document_graph;
        fts_cache_t*    cache;          
};

struct fts_index_cache_t {
        dict_index_t*   index;          
        ib_rbt_t*       words;          
        ib_vector_t*    doc_stats;      
        que_t**         ins_graph;      
        que_t**         sel_graph;      
        CHARSET_INFO*   charset;        
};

struct fts_update_t {
        doc_id_t        doc_id;         
        ib_vector_t*    fts_indexes;    
};

struct fts_stopword_t {
        ulint           status;         
        ib_alloc_t*     heap;           
        ib_rbt_t*       cached_stopword;
        CHARSET_INFO*   charset;        
};

struct fts_sync_t {
        trx_t*          trx;            
        dict_table_t*   table;          
        ulint           max_cache_size; 
        ibool           cache_full;     
        ulint           lower_index;    
        ulint           upper_index;    
        ibool           interrupted;    
        doc_id_t        min_doc_id;     
        doc_id_t        max_doc_id;     
        ib_time_t       start_time;     
};

struct fts_cache_t {
        rw_lock_t       lock;           
        rw_lock_t       init_lock;      
        ib_mutex_t      optimize_lock;  
        ib_mutex_t      deleted_lock;   
        ib_mutex_t      doc_id_lock;    
        ib_vector_t*    deleted_doc_ids;
        ib_vector_t*    indexes;        
        ib_vector_t*    get_docs;       
        ulint           total_size;     
        fts_sync_t*     sync;           
        ib_alloc_t*     sync_heap;      
        ib_alloc_t*     self_heap;      
        doc_id_t        next_doc_id;    
        doc_id_t        synced_doc_id;  
        doc_id_t        first_doc_id;   
        ulint           deleted;        
        ulint           added;          
        fts_stopword_t  stopword_info;  
        mem_heap_t*     cache_heap;     
};

struct fts_node_t {
        doc_id_t        first_doc_id;   
        doc_id_t        last_doc_id;    
        byte*           ilist;          
        ulint           doc_count;      
        ulint           ilist_size;     
        ulint           ilist_size_alloc;
};

struct fts_tokenizer_word_t {
        fts_string_t    text;           
        ib_vector_t*    nodes;          
};

struct fts_word_t {
        fts_string_t    text;           
        ib_vector_t*    nodes;          
        ib_alloc_t*     heap_alloc;     
};

struct fts_fetch_t {
        void*           read_arg;       
        fts_sql_callback
                        read_record;    
};

struct fts_index_selector_t {
        ulint           value;          
        const char*     suffix;         
};

struct fts_doc_t {
        fts_string_t    text;           
        ibool           found;          
        ib_rbt_t*       tokens;         
        ib_alloc_t*     self_heap;      
        CHARSET_INFO*   charset;        
};

struct fts_token_t {
        fts_string_t    text;           
        ib_vector_t*    positions;      
};

extern const fts_index_selector_t fts_index_selector[];

/******************************************************************/
UNIV_INLINE
int
fts_utf8_string_cmp(
/*================*/
        const void*     p1,                     
        const void*     p2);                    
/******************************************************************/
UNIV_INLINE
int
fts_utf8_string_cmp_prefix(
/*=======================*/
        const void*     p1,                     
        const void*     p2);                    
/******************************************************************/
UNIV_INLINE
int
fts_trx_row_doc_id_cmp(
/*===================*/
        const void*     p1,                     
        const void*     p2);                    
/******************************************************************/
UNIV_INLINE
int
fts_ranking_doc_id_cmp(
/*===================*/
        const void*     p1,                     
        const void*     p2);                    
/******************************************************************/
UNIV_INLINE
int
fts_update_doc_id_cmp(
/*==================*/
        const void*     p1,                     
        const void*     p2);                    
/******************************************************************/
UNIV_INLINE
ulint
fts_decode_vlc(
/*===========*/
        byte**  ptr);   
/******************************************************************/
UNIV_INLINE
void
fts_utf8_string_dup(
/*================*/
        fts_string_t*           dst,            
        const fts_string_t*     src,            
        mem_heap_t*             heap);          
/******************************************************************/
UNIV_INLINE
ulint
fts_get_encoded_len(
/*================*/
        ulint           val);                   
/******************************************************************/
UNIV_INLINE
ulint
fts_encode_int(
/*===========*/
        ulint           val,                    
        byte*           buf);                   
/******************************************************************/
UNIV_INLINE
ulint
fts_utf8_decode(
/*============*/
        const byte**    ptr);                   
/******************************************************************/
UNIV_INLINE
void
fts_utf8_tolower(
/*=============*/
        fts_string_t*   str);                   
/******************************************************************/
UNIV_INLINE
const char*
fts_get_suffix(
/*===========*/
        ulint           selected);              
/********************************************************************
Get the number of index selectors. */
UNIV_INLINE
ulint
fts_get_n_selectors(void);
/*=====================*/

/******************************************************************/
UNIV_INLINE
ulint
fts_select_index(
/*=============*/
        const CHARSET_INFO*     cs,             
        const byte*             str,            
        ulint                   len);           
/********************************************************************
Select the next FTS auxiliary index for the given character.
@return the next index to use for character */
UNIV_INLINE
ulint
fts_select_next_index(
/*==================*/
        const CHARSET_INFO*     cs,             
        const byte*             str,            
        ulint                   len);           
#ifndef UNIV_NONINL
#include "fts0types.ic"
#include "fts0vlc.ic"
#endif

#endif /* INNOBASE_FTS0TYPES_H */