pars0sym.h

Go to the documentation of this file.

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

Copyright (c) 1997, 2009, 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 pars0sym_h
#define pars0sym_h

#include "univ.i"
#include "que0types.h"
#include "usr0types.h"
#include "dict0types.h"
#include "pars0types.h"
#include "row0types.h"

/******************************************************************/
UNIV_INTERN
sym_tab_t*
sym_tab_create(
/*===========*/
        mem_heap_t*     heap);  
/******************************************************************/
UNIV_INTERN
void
sym_tab_free_private(
/*=================*/
        sym_tab_t*      sym_tab);       
/******************************************************************/
UNIV_INTERN
sym_node_t*
sym_tab_add_int_lit(
/*================*/
        sym_tab_t*      sym_tab,        
        ulint           val);           
/******************************************************************/
UNIV_INTERN
sym_node_t*
sym_tab_add_str_lit(
/*================*/
        sym_tab_t*      sym_tab,        
        const byte*     str,            
        ulint           len);           
/******************************************************************/
UNIV_INTERN
sym_node_t*
sym_tab_add_bound_lit(
/*==================*/
        sym_tab_t*      sym_tab,        
        const char*     name,           
        ulint*          lit_type);      
/**********************************************************************
Rebind literal to a node in the symbol table. */

sym_node_t*
sym_tab_rebind_lit(
/*===============*/
                                        /* out: symbol table node */
        sym_node_t*     node,           /* in: node that is bound to literal*/
        const void*     address,        /* in: pointer to data */
        ulint           length);        /* in: length of data */
/******************************************************************/
UNIV_INTERN
sym_node_t*
sym_tab_add_null_lit(
/*=================*/
        sym_tab_t*      sym_tab);       
/******************************************************************/
UNIV_INTERN
sym_node_t*
sym_tab_add_id(
/*===========*/
        sym_tab_t*      sym_tab,        
        byte*           name,           
        ulint           len);           
/******************************************************************/
UNIV_INTERN
sym_node_t*
sym_tab_add_bound_id(
/*===========*/
        sym_tab_t*      sym_tab,        
        const char*     name);          
#define SYM_CLUST_FIELD_NO      0

#define SYM_SEC_FIELD_NO        1

enum sym_tab_entry {
        SYM_UNSET,              
        SYM_VAR = 91,           
        SYM_IMPLICIT_VAR,       
        SYM_LIT,                
        SYM_TABLE_REF_COUNTED,  
        SYM_TABLE,              
        SYM_COLUMN,             
        SYM_CURSOR,             
        SYM_PROCEDURE_NAME,     
        SYM_INDEX,              
        SYM_FUNCTION            
};

struct sym_node_t{
        que_common_t                    common;         
        /* NOTE: if the data field in 'common.val' is not NULL and the symbol
        table node is not for a temporary column, the memory for the value has
        been allocated from dynamic memory and it should be freed when the
        symbol table is discarded */

        /* 'alias' and 'indirection' are almost the same, but not quite.
        'alias' always points to the primary instance of the variable, while
        'indirection' does the same only if we should use the primary
        instance's values for the node's data. This is usually the case, but
        when initializing a cursor (e.g., "DECLARE CURSOR c IS SELECT * FROM
        t WHERE id = x;"), we copy the values from the primary instance to
        the cursor's instance so that they are fixed for the duration of the
        cursor, and set 'indirection' to NULL. If we did not, the value of
        'x' could change between fetches and things would break horribly.

        TODO: It would be cleaner to make 'indirection' a boolean field and
        always use 'alias' to refer to the primary node. */

        sym_node_t*                     indirection;    
        sym_node_t*                     alias;          
        UT_LIST_NODE_T(sym_node_t)      col_var_list;   
        ibool                           copy_val;       
        ulint                           field_nos[2];   
        ibool                           resolved;       
        enum sym_tab_entry              token_type;     
        const char*                     name;           
        ulint                           name_len;       
        dict_table_t*                   table;          
        ulint                           col_no;         
        sel_buf_t*                      prefetch_buf;   
        sel_node_t*                     cursor_def;     
        ulint                           param_type;     
        sym_tab_t*                      sym_table;      
        UT_LIST_NODE_T(sym_node_t)      sym_list;       
        sym_node_t*                     like_node;      /* LIKE operator node*/
};

struct sym_tab_t{
        que_t*                  query_graph;
        const char*             sql_string;
        size_t                  string_len;
        int                     next_char_pos;
        pars_info_t*            info;   
        sym_node_list_t         sym_list;
        UT_LIST_BASE_NODE_T(func_node_t)
                                func_node_list;
        mem_heap_t*             heap;   
};

#ifndef UNIV_NONINL
#include "pars0sym.ic"
#endif

#endif