.nf
 
 
    ========== licence begin  GPL
    Copyright (C) 2000 SAP AG
 
    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; either version 2
    of the License, or (at your option) any later version.
 
    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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    ========== licence end
 
.fo
*****************************************************
Copyright by SAP AG, 2000
SAP Database Technology
 
Release :      Date : 2000-11-23
*****************************************************
modname : VKB720
changed : 2000-11-23
module  : Single_Select
 
Author  : ElkeZ
Created : 1987-09-22
*****************************************************
 
Purpose : Search in one table using the strategy
          information build in AK
 
Define  :
 
        PROCEDURE
              k720finish_catalog_select (
                    VAR m             : tgg_mess_block;
                    VAR sel           : tgg_select_fields_param;
                    VAR strat         : tgg07_StrategyInfo;
                    VAR selrec_ctxt   : tsp_buf;
                    VAR getrec        : tkb7_get_param;
                    VAR select_vars   : tgg07_K720selectVars;
                    VAR lbuf          : tgg_rec_buf);
 
        PROCEDURE
              k720init_ref_statistic;
 
        PROCEDURE
              k720ref_statistic (
                    VAR m         : tgg_mess_block;
                    VAR arr_index : tgg_ref_info_index;
                    VAR strat     : tgg07_StrategyInfo);
&       ifdef trace
 
        FUNCTION
              k720sel_param_size : integer;
 
        FUNCTION
              k720get_param_size : integer;
 
        PROCEDURE
              k720trace_selrec (VAR selrec : tkb7_select_param);
&       endif
 
        PROCEDURE
              k720start_catalog_select (
                    VAR m             : tgg_mess_block;
                    VAR sel           : tgg_select_fields_param;
                    VAR gg_strategy   : tgg07_StrategyInfo;
                    VAR selrec_ctxt   : tsp_buf;
                    VAR select_vars   : tgg07_K720selectVars);
 
        PROCEDURE
              k720monitor (
                    VAR trans         : tgg00_TransContext;
                    VAR sel           : tgg_select_fields_param;
                    start_sec         : tsp_int4;
                    start_microsec    : tsp_int4;
                    start_phys_ios    : tsp_int4;
                    start_suspends    : tsp_int4;
                    start_waits       : tsp_int4;
                    put_strat         : boolean;
                    arr_index         : tgg_ref_info_index;
                    strat_cnt         : boolean);
 
        PROCEDURE
              k720show_monitor (VAR info : tgg00_ReferenceInfo);
 
        PROCEDURE
              k720_initialize (
                    VAR m                : tgg_mess_block;
                    VAR selrec           : tkb7_select_param;
                    VAR gg_strategy      : tgg07_StrategyInfo;
                    VAR use_stopkey      : boolean;
                    VAR finding_possible : boolean);
 
        PROCEDURE
              k720_select (
                    VAR m      : tgg_mess_block;
                    VAR getrec : tkb7_get_param;
                    VAR selrec : tkb7_select_param);
 
        PROCEDURE
              k720_single_select (VAR m : tgg_mess_block);
 
        PROCEDURE
              k720_test_subquery (
                    VAR m   : tgg_mess_block;
                    VAR rec : tgg_rec_buf);
 
        PROCEDURE
              k720apply_aggr_func (
                    VAR funct_fields : tgg_aggr_descr_rec;
                    VAR listkey      : tgg_lkey;
                    VAR lbuf         : tsp_buf;
                    one_list_only    : boolean;
                    VAR e            : tgg_basis_error);
 
        PROCEDURE
              k720_maxresult_get (
                    VAR data           : tsp_moveobj;
                    strat_maxcnt       : tsp_int2;
                    VAR maxresult      : tsp_int4;
                    VAR b_err          : tgg_basis_error);
 
.CM *-END-* define --------------------------------------
***********************************************************
 
Use     :
 
        FROM
              Scanner : VAK01;
 
        VAR
              a01diag_monitor_on : boolean;
              a01diag_analyze_on : boolean;
 
      ------------------------------ 
 
        FROM
              Build_Strategy : VAK70;
 
        VAR
              a70glob_fetch_strats      : tgg07_StratEnumSet;
              a70glob_inv_strats        : tgg07_StratEnumSet;
&       ifdef trace
 
      ------------------------------ 
 
        FROM
              Trace_Strategy_1 : VAK725;
 
        PROCEDURE
              a725output_gg_strat (
                    debug         : tgg_debug;
                    nam           : tsp00_Sname;
                    VAR gg_strat  : tgg07_StrategyInfo;
                    StratInfo_len : tsp_int2);
&       endif
 
      ------------------------------ 
 
        FROM
              Build_Strategy_2 : VAK71;
 
        FUNCTION
              a71is_duplicate_avoidance (
                    VAR gg_strategy  : tgg07_StrategyInfo;
                    stratenum        : tgg07_StratEnum;
                    VAR strat_data   : tgg07_StrRaw) : boolean;
 
      ------------------------------ 
 
        FROM
              KB_transaction : VKB53;
 
        PROCEDURE
              k53wait (
                    VAR t     : tgg00_TransContext;
                    MessType  : tgg00_MessType;
                    MessType2 : tgg00_MessType2);
 
        PROCEDURE
              k53perm_temp_lock (
                    VAR t          : tgg00_TransContext;
                    lock_unlock    : tgg00_MessType;
                    lock_mode      : tgg00_LockReqMode;
                    lock_handling  : tgg00_HandlingSet;
                    VAR lock_tabid : tgg00_Surrogate;
                    VAR k          : tgg00_Lkey);
 
      ------------------------------ 
 
        FROM
              KB_inv_link_trigger_handling : VKB62;
 
        PROCEDURE
              k62return_trigger (VAR m : tgg00_MessBlock);
 
      ------------------------------ 
 
        FROM
              KB_get : VKB71;
 
        PROCEDURE
              k71sub_value_get (
                    VAR t   : tgg00_TransContext;
                    VAR op  : tgg_stack_entry;
                    dataptr : tsp_moveobj_ptr;
                    datasize: integer);
 
      ------------------------------ 
 
        FROM
              Single_Select_Part2: VKB721;
 
        PROCEDURE
              k721call_later_output (
                    VAR m    : tgg_mess_block;
                    VAR buf  : tsp_buf;
                    m_keylen : integer);
 
        PROCEDURE
              k721do_avg (
                    VAR m        : tgg_mess_block;
                    VAR selrec   : tkb7_select_param;
                    later_output : boolean;
                    m_keylen     : integer);
 
        PROCEDURE
              k721do_rowno (
                    VAR m      : tgg_mess_block;
                    VAR selrec : tkb7_select_param);
 
        PROCEDURE
              k721null_result (
                    VAR m         : tgg_mess_block;
                    VAR selrec    : tkb7_select_param;
                    VAR sel       : tgg_select_fields_param;
                    act_cntresult : tsp_int4;
                    later_output  : boolean;
                    m_keylen      : integer);
 
        PROCEDURE
              k721strat_distribution (
                    VAR m                : tgg_mess_block;
                    VAR getrec           : tkb7_get_param;
                    VAR selrec           : tkb7_select_param;
                    VAR sel              : tgg_select_fields_param;
                    VAR strat            : tgg07_StrategyInfo;
                    VAR finding_possible : boolean);
 
        FUNCTION
              k721out_entry (
                    mb_st : tgg_stack_list_ptr;
                    curr : integer) : integer;
 
      ------------------------------ 
 
        FROM
              Single_Select : VKB73;
 
        PROCEDURE
              k73_index_range (
                    VAR m                : tgg_mess_block;
                    VAR getrec           : tkb7_get_param;
                    VAR selrec           : tkb7_select_param;
                    VAR sel              : tgg_select_fields_param;
                    VAR strat            : tgg07_StrategyInfo;
                    VAR finding_possible : boolean);
 
        PROCEDURE
              k73_seq_search (
                    VAR m            : tgg_mess_block;
                    VAR selrec       : tkb7_select_param;
                    VAR sel          : tgg_select_fields_param;
                    VAR strat        : tgg07_StrategyInfo;
                    finding_possible : boolean);
 
      ------------------------------ 
 
        FROM
              KB_Join_Select : VKB74;
 
        PROCEDURE
              k74rowno_position (
                    VAR m      : tgg_mess_block;
                    VAR getrec : tkb7_get_param;
                    VAR selrec : tkb7_select_param);
 
      ------------------------------ 
 
        FROM
              filesysteminterface_1 : VBD01;
 
        VAR
              b01niltree_id     : tgg00_FileId;
 
        PROCEDURE
              b01move_filecontent (
                    VAR t         : tgg00_TransContext;
                    VAR source_id : tgg00_FileId;
                    VAR target_id : tgg00_FileId);
 
        PROCEDURE
              b01tcreate_file (
                    VAR t           : tgg00_TransContext;
                    VAR act_tree_id : tgg00_FileId);
 
        PROCEDURE
              b01destroy_file (
                    VAR t           : tgg00_TransContext;
                    VAR act_tree_id : tgg00_FileId);
 
        PROCEDURE
              b01prefix_destroy_files (
                    VAR t         : tgg00_TransContext;
                    VAR prefix_fn : tgg00_Filename;
                    prefix_len    : integer);
 
        PROCEDURE
              b01empty_file (
                    VAR t       : tgg00_TransContext;
                    VAR current : tgg00_FileId);
 
        PROCEDURE
              b01treset_file (
                    VAR t       : tgg00_TransContext;
                    VAR current : tgg00_FileId);
 
        PROCEDURE
              b01vstate_fileversion (VAR t : tgg00_TransContext;
                    VAR file_id : tgg00_FileId);
 
      ------------------------------ 
 
        FROM
              filesysteminterface_7 : VBD07;
 
        PROCEDURE
              b07cadd_record (
                    VAR t           : tgg00_TransContext;
                    VAR act_tree_id : tgg00_FileId;
                    VAR b           : tsp_buf);
 
        PROCEDURE
              b07cprev_record (
                    VAR t           : tgg00_TransContext;
                    VAR act_tree_id : tgg00_FileId;
                    VAR rk          : tgg00_Lkey;
                    VAR set_result  : tgg00_BdSetResultRecord;
                    VAR tree_pos    : tgg00_FilePos;
                    VAR b           : tsp_buf);
 
        PROCEDURE
              b07cnext_record (
                    VAR t           : tgg00_TransContext;
                    VAR act_tree_id : tgg00_FileId;
                    VAR rk          : tgg00_Lkey;
                    VAR set_result  : tgg00_BdSetResultRecord;
                    VAR tree_pos    : tgg00_FilePos;
                    VAR b           : tsp00_MoveObj);
 
        PROCEDURE
              b07cdel_record (
                    VAR t           : tgg00_TransContext;
                    VAR act_tree_id : tgg00_FileId;
                    VAR rk          : tgg00_Lkey);
 
        PROCEDURE
              b07cget_record (
                    VAR t       : tgg00_TransContext;
                    VAR file_id : tgg00_FileId;
                    VAR rk      : tgg00_Lkey;
                    VAR b       : tsp_buf);
 
      ------------------------------ 
 
        FROM
              task_temp_data_cache : VBD21;
 
        PROCEDURE
              b21m_reset_monitor (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    reset_sum : boolean);
 
        PROCEDURE
              b21mp_copy_result_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    copy_result : tsp00_C3);
 
        PROCEDURE
              b21mp_kb_calls_put (temp_cache_ptr : tgg00_TempDataCachePtr);
 
        PROCEDURE
              b21mp_microsec_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    microsec : tsp00_Int4);
 
        PROCEDURE
              b21mp_new_sum_put (temp_cache_ptr : tgg00_TempDataCachePtr);
 
        PROCEDURE
              b21mp_phys_ios_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    phys_ios : tsp00_Int4);
 
        PROCEDURE
              b21mp_rows_qual_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    rows_qual : tsp00_Int4);
 
        PROCEDURE
              b21mp_rows_read_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    rows_read : tsp00_Int4);
 
        PROCEDURE
              b21mp_sec_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    sec : tsp00_Int4);
 
        PROCEDURE
              b21mp_strat_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    VAR strategy : tsp00_C40;
                    len : tsp_int4);
 
        PROCEDURE
              b21mp_suspends_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    suspends : tsp00_Int4);
 
        PROCEDURE
              b21mp_virt_reads_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    virt_reads : tsp00_Int4);
 
        PROCEDURE
              b21mp_waits_put (
                    temp_cache_ptr : tgg00_TempDataCachePtr;
                    waits : tsp00_Int4);
 
      ------------------------------ 
 
        FROM
              ref_statistic : VBD73;
 
        VAR
              b73spage_ref_statistic : boolean;
 
        PROCEDURE
              b73cmd_count (statement_kind : tgg00_RefInfoIndex);
 
        PROCEDURE
              b73cmds_count (
                    statement_kind : tgg00_RefInfoIndex;
                    count : tsp00_Int4);
 
      ------------------------------ 
 
        FROM
              Configuration_Parameter : VGG01;
 
        VAR
              g01localsite : tgg_serverdb_no;
              g01vtrace    : tgg_vtrace_state;
 
      ------------------------------ 
 
        FROM
              Select_Help_Procedures : VGG04;
 
        PROCEDURE
              g04init_select_fields (
                    VAR sel       : tgg_select_fields_param;
                    data_addr     : tsp_moveobj_ptr;
                    data_size     : tsp_int4;
                    work_st_addr  : tgg_stack_list_ptr;
                    work_st_max   : tsp_int2;
                    work_buf_addr : tsp_moveobj_ptr;
                    work_buf_size : tsp_int4;
                    curr_sqlmode  : tsp_sqlmode);
 
        PROCEDURE
              g04limitprimkeys (
                    VAR m           : tgg_mess_block;
                    VAR startkeyarr : tgg07_ColPosArr;
                    VAR start_key   : tgg_lkey;
                    VAR stopkeyarr  : tgg07_ColPosArr;
                    VAR stop_key    : tgg_lkey;
                    VAR use_stopkey : boolean;
                    in_stack        : tsp_int2;
                    in_cnt          : tsp_int2);
 
        PROCEDURE
              g04inbetween_change (
                    VAR m                : tgg_mess_block;
                    VAR finding_possible : boolean);
 
        PROCEDURE
              g04build_temp_tree_id (
                    VAR curr : tgg00_FileId;
                    VAR t : tgg00_TransContext);
 
        PROCEDURE
              g04spec_null_check (
                    VAR m     : tgg_mess_block;
                    VAR b_err : tgg_basis_error);
 
        PROCEDURE
              g04statistic_trace (
                    VAR t     : tgg00_TransContext;
                    arr_index : tgg_ref_info_index;
                    int1      : tsp_int4;
                    int2      : tsp_int4;
                    int3      : tsp_int4;
                    int4      : tsp_int4);
 
        PROCEDURE
              g04find_in_stack (
                    VAR m           : tgg_mess_block;
                    VAR keyarr      : tgg07_ColPosArr;
                    VAR in_stack    : tsp_int2;
                    VAR in_cnt      : tsp_int2);
 
      ------------------------------ 
 
        FROM
              RTE-Extension-10 : VSP10;
 
        PROCEDURE
              s10fil (
                    size     : tsp_int4;
                    VAR m    : tgg_mess_info_buf;
                    pos      : tsp_int4;
                    len      : tsp_int4;
                    fillchar : char);
 
      ------------------------------ 
 
        FROM
              Kernel_move_and_fill : VGG10;
 
        PROCEDURE
              g10fil  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;
                    VAR source     : tsp_key;
                    source_pos     : tsp_int4;
                    length         : tsp_int4;
                    fill_char      : char;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10fil1 (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;
                    VAR source     : tsp_buf;
                    source_pos     : tsp_int4;
                    length         : tsp_int4;
                    fill_char      : char;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv   (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;
                    destin_upb     : tsp_int4;
                    VAR source     : tsp_moveobj;
                    source_pos     : tsp_int4;
                    VAR destin     : tgg07_StrategyInfo;
                    destin_pos     : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv1  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;    destin_upb : tsp_int4;
                    VAR source     : tsp_moveobj; source_pos : tsp_int4;
                    VAR destin     : tsp_key;     destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv2  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;    destin_upb : tsp_int4;
                    VAR source     : tgg00_FileId; source_pos : tsp_int4;
                    VAR destin     : tsp_moveobj; destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv3  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;    destin_upb : tsp_int4;
                    VAR source     : tsp_moveobj; source_pos : tsp_int4;
                    VAR destin     : tgg00_FileId; destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv4  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4; destin_upb : tsp_int4;
                    VAR source     : tsp_buf;  source_pos : tsp_int4;
                    VAR destin     : tsp_buf;  destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv6  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4; destin_upb : tsp_int4;
                    VAR source     : tsp_key;  source_pos : tsp_int4;
                    VAR destin     : tsp_key;  destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv8  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;          destin_upb : tsp_int4;
                    VAR source     : tkb7_select_param; source_pos : tsp_int4;
                    VAR destin     : tsp_buf;           destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
        PROCEDURE
              g10mv9  (
                    mod_id         : tsp_c6;
                    mod_intern_num : tsp_int4;
                    source_upb     : tsp_int4;          destin_upb : tsp_int4;
                    VAR source     : tsp_buf;           source_pos : tsp_int4;
                    VAR destin     : tkb7_select_param; destin_pos : tsp_int4;
                    length         : tsp_int4;
                    VAR e          : tgg_basis_error);
 
      ------------------------------ 
 
        FROM
              RTE_kernel : VEN101;
 
        PROCEDURE
              vclock (
                    VAR sec      : tsp_int4;
                    VAR microsec : tsp_int4);
 
        PROCEDURE
              vmonitor (
                    pid          : tsp_process_id;
                    VAR phys_ios : tsp_int4;
                    VAR suspends : tsp_int4;
                    VAR waits    : tsp_int4);
 
      ------------------------------ 
 
        FROM
              GET-Conversions : VSP40;
 
        PROCEDURE
              s40glint (
                    VAR buf  : tsp_moveobj;
                    pos      : tsp_int4;
                    len      : integer;
                    VAR dest : tsp_int4;
                    VAR res  : tsp_num_error);
 
      ------------------------------ 
 
        FROM
              PUT-Conversions : VSP41;
 
        PROCEDURE
              s41p4int (
                    VAR buf : tsp_resnum;
                    pos     : tsp_int4;
                    source  : tsp_int4;
                    VAR res : tsp_num_error);
 
      ------------------------------ 
 
        FROM
              Number-Arithmetic : VSP51;
 
        PROCEDURE
              s51add (
                    VAR left       : tsp_buf;
                    lpos           : tsp_int4;
                    llen           : integer;
                    VAR right      : tsp_key;
                    rpos           : tsp_int4;
                    rlen           : integer;
                    VAR result     : tsp_buf;
                    respos         : tsp_int4;
                    reslen         : integer;
                    resfrac        : integer;
                    VAR resbytelen : integer;
                    VAR ret        : tsp_num_error);
&       IFDEF TRACE
 
      ------------------------------ 
 
        FROM
              Test_Procedures : VTA01;
 
        PROCEDURE
              t01basis_error (
                    debug : tgg00_Debug;
                    nam   : tsp00_Sname;
                    b_err : tgg00_BasisError);
 
        PROCEDURE
              t01bool (
                    debug    : tgg00_Debug;
                    nam      : tsp00_Sname;
                    curr_bool: boolean);
 
        PROCEDURE
              t01bool2 (
                    debug     : tgg00_Debug;
                    nam1      : tsp00_Sname;
                    bool1     : boolean;
                    nam2      : tsp00_Sname;
                    bool2     : boolean);
 
        PROCEDURE
              t01int4 (
                    debug    : tgg00_Debug;
                    nam      : tsp00_Sname;
                    int      : tsp00_Int4);
 
        PROCEDURE
              t01lkey (
                    level : tgg00_Debug;
                    VAR k : tgg00_Lkey);
 
        PROCEDURE
              t01p2int4 (
                    debug : tgg00_Debug;
                    nam_1 : tsp00_Sname;
                    int_1 : tsp00_Int4;
                    nam_2 : tsp00_Sname;
                    int_2 : tsp00_Int4);
 
        PROCEDURE
              t01qual (
                    level     : tgg00_Debug;
                    VAR part1 : tgg00_QualBuf);
 
        PROCEDURE
              t01site (
                    debug    : tgg00_Debug;
                    nam      : tsp00_Sname;
                    site     : tgg00_ServerdbNo);
 
        FUNCTION
              t01trace (debug : tgg00_Debug) : boolean;
 
        PROCEDURE
              t01treeid  (
                    level    : tgg00_Debug;
                    nam      : tsp00_Sname;
                    VAR tree : tgg00_FileId);
 
        PROCEDURE
              t01strat_enum (
                    debug : tgg00_Debug;
                    nam   : tsp00_Sname;
                    strat : tgg07_StratEnum);
&       ENDIF
 
.CM *-END-* use -----------------------------------------
***********************************************************
 
Synonym :
 
        PROCEDURE
              b07cadd_record;
 
              tgg00_Rec tsp_buf
 
        PROCEDURE
              b07cprev_record;
 
              tsp00_MoveObj tsp_buf
 
        PROCEDURE
              b07cget_record;
 
              tgg00_Rec tsp_buf
 
        PROCEDURE
              s10fil;
 
              tsp_moveobj tgg_mess_info_buf
 
        PROCEDURE
              g10fil;
 
              tsp_moveobj tsp_key
 
        PROCEDURE
              g10fil1;
 
              tsp_moveobj tsp_buf
 
        PROCEDURE
              g10mv;
 
              tsp_moveobj tgg07_StrategyInfo
 
        PROCEDURE
              g10mv1;
 
              tsp_moveobj tsp_key
 
        PROCEDURE
              g10mv2;
 
              tsp_moveobj tgg00_FileId
 
        PROCEDURE
              g10mv3;
 
              tsp_moveobj tgg00_FileId
 
        PROCEDURE
              g10mv4;
 
              tsp_moveobj tsp_buf
 
        PROCEDURE
              g10mv6;
 
              tsp_moveobj tsp_key
 
        PROCEDURE
              g10mv8;
 
              tsp_moveobj tkb7_select_param
              tsp_moveobj tsp_buf
 
        PROCEDURE
              g10mv9;
 
              tsp_moveobj tsp_buf
              tsp_moveobj tkb7_select_param
 
        PROCEDURE
              s41p4int;
 
              tsp_moveobj tsp_resnum
 
        PROCEDURE
              s51add;
 
              tsp_moveobj tsp_buf
              tsp_moveobj tsp_key
              tsp_moveobj tsp_buf
 
.CM *-END-* synonym -------------------------------------
***********************************************************
 
Specification:
 
K720_INITIALIZE
------------------------
 
The strategy, file names, file versions, maximum permissible result
count, primary startkey and primary stopkey are transferred from
the mess_buffer to suitable structures that are used
in the further processing.
 
K720_TEST_SUBQUERY
------------------------
 
For each qualification that contains a subquery, a check is run to
find out whether the (previously executed) subquery has supplied at
least one result so that, if applicable, unnecessary searching can
be avoided during the qualification check of individual table records.
 
.CM *-END-* specification -------------------------------
***********************************************************
 
Description:
 
K720_INITIALIZE is used to initialize strat, finding_possible and
parts of selrec.  As in AK, the strategy information or, if there is
more than one strategy, the first part of the strategies is
available in strat.  Finding_possible indicates whether any
table record could possibly fulfill the condition or whether, for
example, a 'between' condition with lower limit > upper limit
renders it impossible and, therefore, the search need not take place
at all.
If there is more than one strategy (cnt_strat > 1) and duplicate
records are not to be deleted in any case, a help file is
generated.  The primary key of the particular record from which the
result record to be processed was formed is then entered in this
help file.  If the key is already present, the result record can no
longer be entered.  Example:  Primary record with field1 = 'Mueller',
field2 = 3.  Query: WHERE field1 = 'Mueller' OR field2 = 3.
 
There are never result files for FETCH-strategies, for
set updates or set deletes or for insert-selects.  If the result is
supposed to be written to the file that exists throughout the
entire session (res_tabname = blankname), the 'current' that was
transferred is used; otherwise, a file with the transferred name is
generated.
One_result means that the result is not entered in a file but
is entered in a buffer that is available in selrec.  BD orders and
I/Os are not necessary.
In the case of search orders with functions (SUM, AVG, etc ],
'distinct' files are used to ensure that one file each is available
for DISTINCT AVG|SUM|COUNT in which the distinctness can be checked
before a result record is added to those that have
already accumulated or counted.
K720_TEST_SUBQUERY is called if any subquery is contained in the
qualification. If appropriate, the stack entries are thereby manipulated
in order to avoid unnecessary accesses to the subquery during the
search operation in the primary data because the resulting knowledge
(false or true result) is independent of the primary data and,
for this reason, are already to be determined and entered in the
stack entries at this time.
Since, in the case of search conditions with 'OR', several search
strategies sometimes must be processed consecutively, this is
executed in a 'while' loop.  After KB720NEXT_STRAT has been processed,
strat always looks as though there is only one strategy, on the end
of which are currently appended totally uninteresting bytes.
The CASE clause divides the strategies into two large categories:
FETCH-strategies and all others. FETCH_strategies
signify that, at the time of the select, a check should be
run only to determine whether any result exists.  If no, the user
immediately receives the error row_not_found at the time of the select.
If yes, he is informed that the resultcount is unknown but
at least one result exists.  These results, however, are not retrieved from
the database until subsequent fetch operations are performed.
For non FETCH-strategies, the entire search is performed
at the time of the select.  The results are copied to a temporary
result table.  From there they can be retrieved by 'fetch' without
a complicated search and qualification test.
The processing of all FETCH-strategies takes place in VKB73. Some
parts of the procedure must be executed in any case, regardless of
whether the search can be successful or not.
The rest of the strategies are divided into
strat_key_in    : the only key field has been qualified with '=' or 'IN'
strat_key_range : no usable condition via an inverted field exists
strat_inv_range : the first x fields of a multiple, named index have
been qualified with '=', '>','>=','<','<=',BETWEEN or LIKE
strat_join_viewkey : used only for the qualification test of the
updateable join views.  The record whose key is at the beginning of
mb_data is to be found and checked.
 
If all strategies have been processed, the file is deleted
that was generated only if there was more than one strategy.
Any files that may have been generated for DISTINCT AVG|SUM|COUNT
are also deleted.
The AVG values are formed from the stored sums and record counters (DO_AVG).
If there was otherwise no result (NULL_RESULT),
a record with NULL or 0 values is generated.
If rowno was in the output list during the select, the rowno value
is installed at the appropriate positions (call of K720_DO_ROWNO).
Then either the number of results found is supplied (strategies
without fe_, no SELECT .. INTO) or the result record is transferred
from the auxiliary buffer or from the file to mb_data of the
mess_buffer.  The record must be removed from the file.
In the case of an error, the result file must either be entirely
deleted or emptied.
 
K720_INITIALIZE
------------------------
 
The strategy is transferred from the mess_buffer to the associated
record; result counters and file names are initialized.  For
insert-select, the 2 fileversions (of the file to be searched and
the file into
which insertion is to be made) are kept separate. Positions 7 and
8 of mb_data determine what should be done with duplicates during the
insert (dupl).
 
K74_MAXRESULT_GET
------------------------
 
K74_MAXRESULT_GET is used to determine the maximum number of
results that can be issued (e.g. for SELECT .. INTO, only 1).
Within the strategies, the stack entry positions are increased for
joins (also for the first select for joins) because the strategies are
determined before the output stack entries are moved ahead of
the qualification stack entries.
For strategies that can have a primary startkey and/or stopkey,
they are formed in G04_LIMITKEYS.
In G04_IN_BETWEEN_CHANGE, duplicate values in 'in' conditions are
removed, 'like' conditions are changed to 'equality' conditions or
'between' conditions whenever possible, 'between' conditions are
changed to 'equality' conditions or finding-possible is set to
'false' if the lower limit in a 'between' condition is higher
than its upper limit and, therefore, the search could never be
successful.
 
KB720DISTINCT_FILES
------------------------
 
This procedure is used to generate and delete files (controlled by
the parameter 'create').  Each DISTINCT AVG|SUM|COUNT (MIN and MAX
are internal only without 'distinct') needs a file into which it
attempts to insert one record whose key consists of the group
values, if specified, and of the value that is to be tested for
its distinctness.
A run-through of the stack entries is facilitated by the fact
that the last qualification stack entry and all function stack
entries indicate how many stack entries there have been since the
previous function stack entry.
 
K720_TEST_SUBQUERY
------------------------
 
The entire qualification is searched according to subquery conditions.
Since subqueries have already been executed, the specified file name
must exist.  An attempt is made to retrieve the last record of the file
in order to check whether or not it is an empty file.  If there is a
record there, it is useful for the qualification test to know whether
or not it has a NULL value (elen_var = 2).
If the file is empty, in order to avoid unnecessary accesses to the
empty file, the result of the condition is entered in a Boolean stack
entry (epos = 0 or 1), depending on whether the subquery condition is
an ALL or an ANY condition or is a negated condition.
 
KB720NEXT_STRAT
------------------------
 
If more than one strategy is required for the search (at least one
'OR' condition was specified), the strategies have the following
structure when they are transferred to KB:
 
 
         88        ||     1         1          ilen     ||
  -----------------||-----------------------------------||
 | strategy header || strat-enum | ilen | strategy data ||
  -----------------||-----------------------------------||
                   ||                                   ||
 
 
The strategy header includes data on file names, result record length
and key length, etc.
Strat-enum indicates the strategy enumeration value.
If there were only one strategy, the strategy header would be
followed by the strategy data only.  Strat-enum is contained in
the strategy header.
Strat-enum is transferred to the strategy header in KB720NEXT_STRAT.
The next strategy data is moved over adjacent to the header.  Further
processing can then be carried out as if there were only 1 strategy.
Leng identifies the length of the strategy data that must be
clipped off the beginning during the next KB720NEXT_STRAT.
In the case of a join-select (or the first select for a join),
the stack entry positions are increased, since the stack entry positions
were established before the output stack entries were shifted to
a position ahead of the qualification stack entries.  For strategies
that can have a primary startkey and/or a primary stopkey, this
is formed in G04_LIMITKEYS.
 
KB720NEW_STPOS
------------------------
 
The number of output stack entries is determined (cntsts).  For all
possible strategies, the stack entry positions are incremented by the
number of output stack entries that were subsequently added.
The stack-entry positions for the primary startkey and primary
stopkey conditions are changed.  Keystop < 0 refers to the upper
limit of a 'between' condition.
 
.CM *-END-* description ---------------------------------
***********************************************************
.CM -lll-
Code    :
 
 
CONST
      c_strat_cnt      = true (* k720monitor      *);
      c_put_strat      = true (* k720monitor      *);
 
VAR
      k720monitor_info : tgg00_ReferenceInfo;
 
 
(*------------------------------*) 
 
PROCEDURE
      k720_select (
            VAR m      : tgg_mess_block;
            VAR getrec : tkb7_get_param;
            VAR selrec : tkb7_select_param);
 
CONST
      c_copy_result     = 'YES';
      c_not_copy_result = 'NO ';
 
VAR
      _old_find_poss  : boolean;
      _aux_error      : tgg_basis_error;
      _start          : integer;
      _stop           : integer;
      _i              : integer;
      _SumStratInfoLen: integer;
      _stratnum       : integer;
      _start_sec      : tsp_int4;
      _start_microsec : tsp_int4;
      _start_phys_ios : tsp_int4;
      _start_suspends : tsp_int4;
      _start_waits    : tsp_int4;
      _selfields      : tgg_select_fields_param;
      _gg_strategy    : tgg07_StrategyInfo;
      _arr_index      : tgg_ref_info_index;
      _select_vars    : tgg07_K720selectVars;
      _b_err          : tgg_basis_error;
 
BEGIN
(* PTS 1001469 E.Z. *)
IF  ( b73spage_ref_statistic OR a01diag_monitor_on OR a01diag_analyze_on )
THEN
    BEGIN
    vclock( _start_sec, _start_microsec );
    vmonitor( m.mb_trns^.trTaskId_gg00, _start_phys_ios, _start_suspends,
          _start_waits );
    END
(* PTS 1001518 E.Z. *)
ELSE
    _start_sec := 0;
(*ENDIF*) 
(* check overflows *)
g04spec_null_check( m, _b_err );
;
IF  ( _b_err = e_ok )
THEN
    kb720sel_first_part( m, selrec, _selfields, _gg_strategy, _select_vars )
ELSE
    m.mb_trns^.trError_gg00 := _b_err;
(*ENDIF*) 
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    BEGIN
    _stratnum := 1;
    IF  ( _select_vars.sv_global_strat in
        [ strat_key_range, strat_key_range_fetch ] )
        AND
        ( _gg_strategy.str_key_in_range.skir_keystart[ 0 ] = 0 ) AND
        ( _gg_strategy.str_key_in_range.skir_keystop [ 0 ] = 0 )
    THEN
        BEGIN
&       ifdef TRACE
        t01strat_enum( ak_strat, 'WARN8 SCAN  ', _select_vars.sv_global_strat );
&       endif
        m.mb_trns^.trWarning_gg00 := m.mb_trns^.trWarning_gg00 +
              [ warn0_exist, warn8_scan_or_sort ];
        END
    ELSE
        selrec.selr_no_warn8_sort :=
              ( NOT _gg_strategy.str_use_order )
              OR
              ( m.mb_type2 in
              [ mm_first_join_select, mm_join_with_last_tab, mm_with_join ] )
              OR
              ( ( selrec.selr_resf_id.fileTfn_gg00 = tfnTemp_egg00 ) AND
              ( selrec.selr_resf_id.fileTfnTemp_gg00 in
              [ ttfnSubquery_egg00, ttfnCorrelation_egg00 ] ));
    (*ENDIF*) 
    IF  ( _select_vars.sv_global_strat in [ strat_key_equal, strat_more_than_one ] )
    THEN
        _selfields.sfp_is_first_record := false;
    (*ENDIF*) 
    _SumStratInfoLen := 0;
    _old_find_poss   := _select_vars.sv_finding_possible;
    ;
    WHILE ( _stratnum <= _gg_strategy.str_cnt_strat ) AND
          ( m.mb_trns^.trError_gg00 = e_ok ) DO
        BEGIN
        m.mb_trns^.trRteCommPtr_gg00^.virt_reads := -csp_maxint2;
        _selfields.sfp_rows_read                 := 0;
        _selfields.sfp_rows_qual                 := 0;
        IF  ( _gg_strategy.str_cnt_strat > 1 )
        THEN
            BEGIN
            kb720next_strat( m, selrec, _gg_strategy,
                  _selfields.sfp_bd_use_stopkey, _SumStratInfoLen );
            IF  ( _stratnum > 1 )
            THEN
                _select_vars.sv_finding_possible := _old_find_poss;
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        ;
&       ifdef trace
        t01qual( kb, m.mb_qual^ );
&       endif
        IF  ( m.mb_trns^.trBdTcachePtr_gg00 <> NIL ) AND
            ( a01diag_monitor_on OR a01diag_analyze_on )
        THEN
            BEGIN
            IF  ( _gg_strategy.str_strategy in a70glob_fetch_strats )
            THEN
                b21mp_copy_result_put( m.mb_trns^.trBdTcachePtr_gg00,
                      c_not_copy_result )
            ELSE
                b21mp_copy_result_put( m.mb_trns^.trBdTcachePtr_gg00,
                      c_copy_result );
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        IF  ( m.mb_trns^.trError_gg00 = e_ok ) AND
            (_gg_strategy.str_strategy in  a70glob_inv_strats) (* PTS 1116600 *)
        THEN
            b01vstate_fileversion( m.mb_trns^, m.mb_qual^.mtree );
        (*ENDIF*) 
        IF  ( m.mb_trns^.trError_gg00 = e_ok )
        THEN
            CASE _gg_strategy.str_strategy OF
                strat_inv_range_merge_fetch,
                strat_inv_range_fetch :
                    k73_index_range( m, getrec, selrec,
                          _selfields, _gg_strategy,
                          _select_vars.sv_finding_possible );
                strat_key_range_fetch :
                    k73_seq_search( m, selrec, _selfields, _gg_strategy,
                          _select_vars.sv_finding_possible );
                OTHERWISE
                    BEGIN
                    IF  ( _select_vars.sv_finding_possible )
                    THEN
                        BEGIN
                        IF  ( selrec.selr_count_all )
                        THEN
                            BEGIN
                            selrec.selr_count_bd :=
                                  NOT selrec.selr_join_with_func;
                            _start := m.mb_qual^.mqual_pos +
                                  m.mb_st^[ m.mb_qual^.mqual_pos ].epos - 1;
                            _stop  := m.mb_qual^.mqual_pos + m.mb_qual^.mqual_cnt - 1;
                            FOR _i := _start TO _stop DO
                                IF  NOT (
                                    ( m.mb_st^[ _i ].etype = st_dummy)
                                    OR
                                    ((m.mb_st^[ _i ].etype = st_bool)
                                    AND
                                    ( m.mb_st^[ _i ].epos = cgg_is_true))
                                    OR
                                    ( m.mb_st^[ _i ].etype = st_jump_false)
                                    OR
                                    ((m.mb_st^[ _i ].etype = st_op)
                                    AND
                                    ( m.mb_st^[ _i ].eop = op_and)))
                                THEN
                                    selrec.selr_count_bd := false;
                                (*ENDIF*) 
                            (*ENDFOR*) 
                            END;
                        (* PTS 1112079 E.Z. *)
                        (*ENDIF*) 
                        _selfields.sfp_check_for_result := false;
                        k721strat_distribution( m, getrec, selrec,
                              _selfields, _gg_strategy,
                              _select_vars.sv_finding_possible );
                        END;
                    (*ENDIF*) 
                    IF  ( m.mb_type = m_select ) AND
                        (selrec.selr_keyl > mxgg_rescnt) (* PTS 1113927 *)
                    THEN
                        b73cmd_count( iins_sorts );
                    (*ENDIF*) 
                    IF  ( _stratnum  = _gg_strategy.str_cnt_strat ) AND
                        ( m.mb_type   =  m_select )               AND
                        ( m.mb_type2  <> mm_first_join_select )   AND
                        ( m.mb_type2  <> mm_with_join )           AND
                        ( m.mb_qual^.mtree.fileTfn_gg00 <> tfnTemp_egg00 ) AND
                        ( hsTempLock_egg00 in m.mb_qual^.mtree.fileHandling_gg00 )
                    THEN
                        BEGIN
                        _aux_error := m.mb_trns^.trError_gg00;
                        k53perm_temp_lock( m.mb_trns^,
                              m_unlock, lckTabShare_egg00,
                              m.mb_qual^.mtree.fileHandling_gg00,
                              m.mb_qual^.mtree.fileTabId_gg00,
                              selrec.selr_invkey (* dummy *) );
                        ;
                        IF  ( _aux_error <> e_ok )
                        THEN
                            m.mb_trns^.trError_gg00 := _aux_error;
                        (*ENDIF*) 
                        END
                    (*ENDIF*) 
                    END
                END;
            (*ENDCASE*) 
        (* PTS 1001518 E.Z. *)
        (*ENDIF*) 
        IF  ( _start_sec > 0 )
        THEN
            IF  ( m.mb_trns^.trError_gg00 <> e_unknown_strategy )  AND
                ( m.mb_qual^.mtree.fileTfn_gg00    <> tfnSys_egg00 )
            THEN
                BEGIN
                k720ref_statistic( m, _arr_index, _gg_strategy );
                k720monitor( m.mb_trns^, _selfields, _start_sec,
                      _start_microsec, _start_phys_ios,_start_suspends,
                      _start_waits, c_put_strat, _arr_index, c_strat_cnt );
                END;
            (*ENDIF*) 
        (*ENDIF*) 
        _stratnum := succ( _stratnum );
        END;
    (*ENDWHILE*) 
    kb720sel_last_part( m, selrec, getrec, _selfields,
          _gg_strategy, _select_vars );
    END
ELSE
    (* m.mb_trns^.trError_gg00 <> e_ok *)
    BEGIN
    m.mb_qual_len  := 0;
    m.mb_data_len  := 0;
    END;
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      kb720distinct_files (
            VAR m                 : tgg_mess_block;
            VAR selrec            : tkb7_select_param;
            VAR disnum            : tsp_int2;
            VAR call_do_avg       : boolean;  (* OUT *)
            VAR call_later_output : boolean); (* OUT *)
 
VAR
      _aux_error : tgg_basis_error;
      _act       : integer;
      _first     : integer;
      _func_cnt  : integer;
      _cnt_pos   : integer;
      _i         : integer;
      _stpos     : integer;
      _htree_id  : tgg00_FileId;
 
BEGIN
call_do_avg := false;
_first      := m.mb_qual^.mqual_pos;
_act        := _first + m.mb_st^[ _first ].epos - 2;
disnum      := 0;
_func_cnt   := 0;
_cnt_pos    := 0;
(* starts with 1, disnum = 0 is used for the *)
(* helpfile for more than one strategies *)
_htree_id := selrec.selr_distinct_id;
&ifdef trace
t01p2int4( ak_strat, 'act         ', _act
      , 'first       ', _first );
&endif
_aux_error       := m.mb_trns^.trError_gg00;
m.mb_trns^.trError_gg00 := e_ok;
WHILE (( _act - m.mb_st^[ _act ].epos > _first ) AND
      ( m.mb_trns^.trError_gg00 = e_ok )) DO
    BEGIN
    m.mb_trns^.trError_gg00 := e_ok;
    _func_cnt := succ( _func_cnt );
    _act      := _act - m.mb_st^[ _act ].epos;
&   ifdef trace
    t01int4( ak_strat, 'act         ', _act );
&   endif
    call_do_avg := call_do_avg OR
          ((m.mb_st^[ _act ].eop_func in
          [ op_f_avg   , op_f_dis_avg,
          op_f_sum     , op_f_dis_sum,
          op_f_stddev  , op_f_dis_stddev,
          op_f_variance, op_f_dis_variance ]) AND
          (m.mb_st^[ _act ].etype = st_func));
    ;
    _stpos := k721out_entry( m.mb_st, _act );
    IF  (( m.mb_st^[ _stpos ].etype = st_output ) AND
        ( m.mb_st^[ _stpos ].eop_out = op_o_output_hold ))
    THEN
        IF  ( m.mb_st^[ _stpos+1 ].eop_out = op_o_output_later )
        THEN
            call_later_output := true;
        (*ENDIF*) 
    (*ENDIF*) 
    IF  ( m.mb_st^[ _act ].etype = st_func )
    THEN
        IF  ( m.mb_st^[ _act ].eop_func = op_f_all_count )
        THEN
            _cnt_pos := _act
        ELSE
            IF  ( m.mb_st^[ _act ].eop_func = op_f_check_null )
            THEN
                _func_cnt := pred( _func_cnt )
            ELSE
                IF  ( m.mb_st^[_act].eop_func = op_f_dis_avg )      OR
                    ( m.mb_st^[_act].eop_func = op_f_dis_sum )      OR
                    ( m.mb_st^[_act].eop_func = op_f_dis_count )    OR
                    ( m.mb_st^[_act].eop_func = op_f_dis_stddev )   OR
                    ( m.mb_st^[_act].eop_func = op_f_dis_variance ) OR
                    ( m.mb_st^[_act].eop_func = op_f_stddev )       OR
                    ( m.mb_st^[_act].eop_func = op_f_variance )
                THEN
                    BEGIN
                    IF  ( disnum < ckb7_maxdistinctfiles )
                    THEN
                        disnum := succ( disnum )
                    ELSE
                        m.mb_trns^.trError_gg00 := e_buffer_limit;
                    (*ENDIF*) 
                    _htree_id.fileTempCnt_gg00 := disnum;
                    _htree_id.fileRootCheck_gg00 := ROOT_CHECK_GG00;
                    IF  ( m.mb_trns^.trError_gg00 = e_ok )
                    THEN
                        BEGIN
                        b01tcreate_file( m.mb_trns^, _htree_id );
                        selrec.selr_disrootarr[disnum].dfi_root       :=
                              _htree_id.fileRoot_gg00;
                        selrec.selr_disrootarr[disnum].dfi_root_check :=
                              _htree_id.fileRootCheck_gg00;
                        END
                    (*ENDIF*) 
                    END
                (*ENDIF*) 
            (*ENDIF*) 
        (*ENDIF*) 
    (*ENDIF*) 
    END;
(*ENDWHILE*) 
IF  ( call_later_output )
THEN
    selrec.selr_keyl := mxgg_rescnt;
(*ENDIF*) 
selrec.selr_count_all := ( selrec.selr_count_all AND
      ( selrec.selr_keyl = mxgg_rescnt ));
_first       := m.mb_qual^.mqual_pos;
_act         := _first + m.mb_st^[ _first ].epos - 2;
;
FOR _i := _first TO _act DO
    IF  ( m.mb_st^[ _i ].etype = st_value )
    THEN
        BEGIN
        (* selrec.selr_count_all := false; *)
        END;
    (*ENDIF*) 
(*ENDFOR*) 
;
&ifdef trace
t01p2int4( ak_strat, 'func_cnt    ', _func_cnt
      , 'cnt_pos     ', _cnt_pos );
t01bool( ak_strat, 'count_all   ', selrec.selr_count_all );
&endif
IF  ( _func_cnt = 1 ) AND ( _cnt_pos > 0 ) AND ( selrec.selr_count_all )
THEN
    BEGIN
    IF  ( NOT selrec.selr_join_with_func )
    THEN
        m.mb_st^[ _cnt_pos ].eop_func := op_f_count_kb;
    (*ENDIF*) 
    END
ELSE
    selrec.selr_count_all  := false;
(*ENDIF*) 
&ifdef trace
t01bool( ak_strat, 'count_all   ', selrec.selr_count_all );
&endif
m.mb_trns^.trError_gg00 := _aux_error;
END;
 
(* PTS 1104018 E.Z. *)
(*------------------------------*) 
 
PROCEDURE
      k720_maxresult_get (
            VAR data           : tsp_moveobj;
            strat_maxcnt       : tsp_int2;
            VAR maxresult      : tsp_int4;
            VAR b_err          : tgg_basis_error);
 
VAR
      _res : tsp_num_error;
 
BEGIN (* h.b. PTS 1001366 *)
IF  strat_maxcnt = cgg_no_rowno_predicate
THEN
    maxresult := csp_maxint4
ELSE
    IF  ( strat_maxcnt = cgg_subquery_one_record )
    THEN
        maxresult := 0
    ELSE
        IF  ( strat_maxcnt = cgg_one_record_at_most_oracle )
        THEN
            maxresult := 0
        ELSE
            IF  ( abs(strat_maxcnt) >= cgg_valid_rowno_pos )
            THEN
                BEGIN
                IF  ( data[  abs(strat_maxcnt) ] = csp_undef_byte ) OR
                    ( data[  abs(strat_maxcnt) ] = csp_default_byte )
                THEN
                    b_err := e_num_invalid
                ELSE
                    BEGIN
                    s40glint( data,
                          abs(strat_maxcnt) + 1, 10, maxresult, _res );
                    IF  strat_maxcnt < 0
                    THEN
                        (* "ROWNO < <int>" predicate ==> "ROWNO <= <int>-1" *)
                        maxresult := pred( maxresult );
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
                IF  ( _res = num_overflow )
                THEN
                    b_err := e_num_overflow
                ELSE
                    IF  ( _res = num_invalid )
                    THEN
                        b_err := e_num_invalid
                    ELSE
                        IF  ( maxresult < 0 )
                        THEN
                            b_err := e_num_invalid
                        (*ENDIF*) 
                    (*ENDIF*) 
                (*ENDIF*) 
                END
            ELSE
                maxresult := strat_maxcnt;
            (*ENDIF*) 
        (*ENDIF*) 
    (*ENDIF*) 
(*ENDIF*) 
&ifdef trace
IF  ( t01trace(kb) )
THEN
    BEGIN
    t01int4( kb, 'maxresult   ', maxresult );
    t01basis_error( kb, 'b_err       ', b_err );
    END
ELSE
    BEGIN
    t01int4( ak_sem, 'maxresult   ', maxresult );
    t01basis_error( ak_sem,'b_err       ', b_err );
    END;
(*ENDIF*) 
&endif
END;
 
(*------------------------------*) 
 
PROCEDURE
      kb720new_stpos (VAR strat : tgg07_StrategyInfo);
 
VAR
      _cntsts    : integer;
      _i         : integer;
 
BEGIN
&IFDEF TRACE
t01int4 (kb, 'stack_offset', strat.str_stack_output_offs);
&ENDIF
_cntsts := strat.str_stack_output_offs;
IF  ( _cntsts <> 0 )
THEN
    WITH strat DO
        BEGIN
        CASE str_strategy OF
            strat_key_in :
                str_key_in_range.skir_IN_SUBQ_stpos :=
                      str_key_in_range.skir_IN_SUBQ_stpos + _cntsts;
            strat_inv_range,
            strat_inv_in,
            strat_inv_range_sub :
                WITH str_inv_in_range DO
                    BEGIN
                    FOR _i := 0 TO siir_startcnt - 1 DO
                        IF  ( siir_invstart[ _i ] > 0 )
                        THEN
                            siir_invstart[ _i ] := siir_invstart[ _i ] + _cntsts
                        ELSE
                            siir_invstart[ _i ] := siir_invstart[ _i ] - _cntsts;
                        (*ENDIF*) 
                    (*ENDFOR*) 
                    FOR _i := 0 TO siir_stopcnt - 1 DO
                        IF  ( siir_invstop[ _i ] > 0 )
                        THEN
                            siir_invstop[ _i ] := siir_invstop[ _i ] + _cntsts
                        ELSE
                            siir_invstop[ _i ] := siir_invstop[ _i ] - _cntsts;
                        (*ENDIF*) 
                    (*ENDFOR*) 
                    IF  siir_IN_SUBQ_stpos <> IS_UNDEFINED_GG07
                    THEN
                        siir_IN_SUBQ_stpos := siir_IN_SUBQ_stpos + _cntsts;
                    (*ENDIF*) 
                    END;
                (*ENDWITH*) 
            OTHERWISE
                BEGIN
                END
            END;
        (*ENDCASE*) 
        IF  NOT ( str_strategy in [ strat_more_than_one, strat_join_viewkey ] )
        THEN
            WITH str_key_in_range DO
                FOR _i := 0 TO MAX_COLPOSARR_IDX_GG07 DO
                    BEGIN
                    IF  ( skir_keystart[ _i ] <> 0 )
                    THEN
                        IF  ( skir_keystart[ _i ] > 0 )
                        THEN
                            skir_keystart[ _i ] := skir_keystart[ _i ] + _cntsts
                        ELSE
                            skir_keystart[ _i ] := skir_keystart[ _i ] - _cntsts;
                        (*ENDIF*) 
                    (*ENDIF*) 
                    IF  ( skir_keystop[ _i ] <> 0 )
                    THEN
                        IF  ( skir_keystop[ _i ] > 0 )
                        THEN
                            skir_keystop[ _i ] := skir_keystop[ _i ] + _cntsts
                        ELSE
                            skir_keystop[ _i ] := skir_keystop[ _i ] - _cntsts
                        (*ENDIF*) 
                    (*ENDIF*) 
                    END
                (*ENDFOR*) 
            (*ENDWITH*) 
        (*ENDIF*) 
        END
    (*ENDWITH*) 
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      kb720next_strat (
            VAR m               : tgg_mess_block;
            VAR selrec          : tkb7_select_param;
            VAR gg_strategy     : tgg07_StrategyInfo;
            VAR use_stopkey     : boolean;
            VAR SumStratInfoLen : tsp_int4);
 
VAR
      _in_stack       : tsp_int2;
      _in_cnt         : tsp_int2;
      _StratInfo_len  : tsp_int4;
      _next_strat_pos : tsp_int4;
 
      _str            : RECORD
            CASE boolean OF
                true  :
                    (strat_char : tsp_c1);
                false :
                    (strat_enum : tgg07_StratEnum);
                END;
            (*ENDCASE*) 
 
 
BEGIN
_next_strat_pos := m.mb_st^[ m.mb_qual^.mstrat_pos ].epos +
      STRATEGY_START_MXGG07 + SumStratInfoLen;
_str.strat_char[ 1 ] := m.mb_strat^[ _next_strat_pos ];
WITH gg_strategy DO
    BEGIN
    str_strategy := _str.strat_enum;
    _StratInfo_len := ord(m.mb_strat^[ _next_strat_pos + 1 ]);
    (* get strategy *)
    g10mv ('VKB720',   1,    
          m.mb_strat_size, sizeof( gg_strategy ),
          m.mb_strat^, _next_strat_pos + 2,
          gg_strategy, STRATEGY_START_MXGG07 + 1,
          _StratInfo_len, m.mb_trns^.trError_gg00);
    SumStratInfoLen := SumStratInfoLen + _StratInfo_len + 2;
    IF  ( m.mb_trns^.trError_gg00 = e_ok )
    THEN
        BEGIN
        IF  (m.mb_type = m_select)
            AND
            ((m.mb_type2 = mm_first_join_select) OR
            (m.mb_type2 = mm_with_join))
        THEN
            kb720new_stpos (gg_strategy);
        (*ENDIF*) 
        IF  str_strategy IN [ strat_key_in, strat_key_equal_sub,
            strat_key_range_sub ]
        THEN
            WITH selrec DO
                BEGIN
                selr_startkey.len := 0;
                selr_stopkey.len  := 0;
                use_stopkey       := false
                END
            (*ENDWITH*) 
        ELSE
            WITH str_key_in_range, selrec DO
                BEGIN
                _in_stack := 0;
                _in_cnt   := 0;
                g04find_in_stack (m, skir_keystart, _in_stack, _in_cnt);
                IF  (_in_stack = 0)
                THEN
                    g04find_in_stack (m, skir_keystop, _in_stack, _in_cnt);
                (*ENDIF*) 
                use_stopkey := true;
                g04limitprimkeys (m, skir_keystart, selr_startkey, skir_keystop,
                      selr_stopkey, use_stopkey, _in_stack, - _in_cnt);
                END;
            (*ENDWITH*) 
        (*ENDIF*) 
        END
    (*ENDIF*) 
    END
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720finish_catalog_select (
            VAR m             : tgg_mess_block;
            VAR sel           : tgg_select_fields_param;
            VAR strat         : tgg07_StrategyInfo;
            VAR selrec_ctxt   : tsp_buf;
            VAR getrec        : tkb7_get_param;
            VAR select_vars   : tgg07_K720selectVars;
            VAR lbuf          : tgg_rec_buf);
 
VAR
      selrec : tkb7_select_param;
 
BEGIN
m.mb_trns^.trError_gg00 := e_ok;
g10mv9 ('VKB720',   2,    
      sizeof (selrec_ctxt), sizeof (selrec),
      selrec_ctxt, 1,
      selrec, sizeof (selrec.selr_selectbuffer) + 1,
      sizeof (selrec) - sizeof (selrec.selr_selectbuffer),
      m.mb_trns^.trError_gg00);
IF  lbuf.len > 0
THEN
    g10mv4 ('VKB720',   3,    
          sizeof (lbuf.buf), sizeof (selrec.selr_selectbuffer.lbuf),
          lbuf.buf, 1, selrec.selr_selectbuffer.lbuf, 1, lbuf.len,
          m.mb_trns^.trError_gg00);
(*ENDIF*) 
kb720sel_last_part (m, selrec, getrec, sel, strat, select_vars);
IF  selrec.selr_keyl > mxgg_rescnt (* PTS 1113927 *)
THEN
    b73cmd_count (iins_sorts);
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720ref_statistic (
            VAR m         : tgg_mess_block;
            VAR arr_index : tgg_ref_info_index;
            VAR strat     : tgg07_StrategyInfo);
 
VAR
      _all_eq : boolean;
      _ix     : tsp_int2;
 
BEGIN
WITH strat DO
    BEGIN
    CASE str_strategy OF
        strat_key_equal,
        strat_key_equal_sub :
            arr_index := iprim_key;
        strat_key_range,
        strat_key_range_fetch,
        strat_key_range_sub,
        strat_key_in :
            IF  (str_key_in_range.skir_keystart[ 0 ] = 0) AND
                (str_key_in_range.skir_keystop[ 0 ]  = 0)
            THEN
                arr_index := itable_scan
            ELSE
                BEGIN
                _all_eq := false;
                _ix     := 0;
                WHILE (_ix <= MAX_COLPOSARR_IDX_GG07) AND NOT _all_eq DO
                    IF  (str_key_in_range.skir_keystart[ _ix ] > 0)
                    THEN
                        IF  (str_key_in_range.skir_keystart[ _ix ] =
                            str_key_in_range.skir_keystop[ _ix ])
                        THEN
                            IF  (m.mb_st^[ str_key_in_range.skir_keystart[_ix]].etype
                                = st_varkey)
                            THEN
                                _all_eq := true
                            ELSE
                                _ix := succ(_ix)
                            (*ENDIF*) 
                        ELSE
                            _ix := MAX_COLPOSARR_IDX_GG07 + 1
                        (*ENDIF*) 
                    ELSE
                        _ix := MAX_COLPOSARR_IDX_GG07 + 1;
                    (*ENDIF*) 
                (*ENDWHILE*) 
                IF  _all_eq
                THEN
                    arr_index := iprim_key
                ELSE
                    arr_index := iprim_key_range;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
        strat_inv_range,
        strat_inv_range_fetch,
        strat_inv_range_merge_fetch,
        strat_inv_range_sub,
        strat_inv_in :
            BEGIN
            _all_eq := ( isp_exact_match in str_inv_in_range.siir_strat_props )
                  OR
                  ( isp_exact_IN_SUBQ_match in
                  str_inv_in_range.siir_strat_props );
            IF  ( _all_eq )
            THEN
                IF  ( str_qual_kind <> inv_only )
                THEN
                    arr_index := iindex
                ELSE
                    arr_index := iis_index
                (*ENDIF*) 
            ELSE
                IF  ( str_qual_kind <> inv_only )
                THEN
                    arr_index := iindex_range
                ELSE
                    arr_index := iis_index_range;
                (*ENDIF*) 
            (*ENDIF*) 
            END;
        strat_join_all_inv_equal,
        strat_join_inv_range,
        strat_join_inv :
            arr_index := iindex_range;
        strat_join_key_range,
        strat_join_viewkey,
        strat_join_key_next :
            arr_index := iprim_key_range;
        strat_join_all_keys_equal,
        strat_join_key_equal :
            arr_index := iprim_key;
        OTHERWISE
            arr_index := ir_v_acc;
        END;
    (*ENDCASE*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720init_ref_statistic;
 
BEGIN
WITH k720monitor_info DO
    BEGIN
    prim_key           := 0;
    prim_key_read      := 0;
    prim_key_qual      := 0;
    prim_key_range     := 0;
    prim_key_range_read:= 0;
    prim_key_range_qual:= 0;
    index              := 0;
    index_read         := 0;
    index_qual         := 0;
    index_range        := 0;
    index_range_read   := 0;
    index_range_qual   := 0;
    is_index           := 0;
    is_index_read      := 0;
    is_index_qual      := 0;
    is_index_range     := 0;
    is_index_range_read:= 0;
    is_index_range_qual:= 0;
    table_scan         := 0;
    table_scan_read    := 0;
    table_scan_qual    := 0;
    is_index_scan      := 0;
    is_index_scan_read := 0;
    is_index_scan_qual := 0;
    END
(*ENDWITH*) 
END;
 
&ifdef trace
(*------------------------------*) 
 
FUNCTION
      k720sel_param_size : integer;
 
BEGIN
k720sel_param_size :=
      sizeof (tkb7_select_param) - sizeof (tgg00_SelectBuffer)
END;
 
(*------------------------------*) 
 
FUNCTION
      k720get_param_size : integer;
 
BEGIN
k720get_param_size := sizeof (tkb7_get_param)
END;
 
&endif
(*------------------------------*) 
 
PROCEDURE
      k720show_monitor (VAR info : tgg00_ReferenceInfo);
 
VAR
      arr_index : tgg_ref_info_index;
 
BEGIN
FOR arr_index := iprim_key TO iis_index_scan_qual DO
    info.reference_array[ arr_index ] :=
          k720monitor_info.reference_array[ arr_index ];
(*ENDFOR*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720start_catalog_select (
            VAR m             : tgg_mess_block;
            VAR sel           : tgg_select_fields_param;
            VAR gg_strategy   : tgg07_StrategyInfo;
            VAR selrec_ctxt   : tsp_buf;
            VAR select_vars   : tgg07_K720selectVars);
 
VAR
      selrec : tkb7_select_param;
 
BEGIN
m.mb_trns^.trError_gg00 := e_ok;
g10mv9 ('VKB720',   4,    
      sizeof (selrec_ctxt), sizeof (selrec), selrec_ctxt, 1,
      selrec, sizeof (selrec.selr_selectbuffer) + 1,
      sizeof (selrec) - sizeof (selrec.selr_selectbuffer), m.mb_trns^.trError_gg00);
;
kb720sel_first_part( m, selrec, sel, gg_strategy, select_vars );
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    BEGIN
&   ifdef trace
    IF  t01trace( kb )
    THEN
        k720trace_selrec( selrec );
&   endif
    (*ENDIF*) 
    g10mv8 ('VKB720',   5,    
          sizeof (selrec), sizeof (selrec_ctxt), selrec,
          sizeof (selrec.selr_selectbuffer) + 1, selrec_ctxt, 1,
          sizeof (selrec) - sizeof (selrec.selr_selectbuffer),
          m.mb_trns^.trError_gg00)
    END;
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720monitor (
            VAR trans         : tgg00_TransContext;
            VAR sel           : tgg_select_fields_param;
            start_sec         : tsp_int4;
            start_microsec    : tsp_int4;
            start_phys_ios    : tsp_int4;
            start_suspends    : tsp_int4;
            start_waits       : tsp_int4;
            put_strat         : boolean;
            arr_index         : tgg_ref_info_index;
            strat_cnt         : boolean);
 
CONST
      _c_reset_sum = true;
 
VAR
      _aux_len       : integer;
      _stop_sec      : tsp_int4;
      _stop_microsec : tsp_int4;
      _diff_sec      : tsp_int4;
      _diff_microsec : tsp_int4;
      _stop_phys_ios : tsp_int4;
      _stop_suspends : tsp_int4;
      _stop_waits    : tsp_int4;
      _aux_c40       : tsp_c40;
 
BEGIN
WITH k720monitor_info, sel DO
    BEGIN
    IF  (trans.trBdTcachePtr_gg00 <> NIL) AND
        (a01diag_monitor_on OR a01diag_analyze_on)
    THEN
        BEGIN
        IF  put_strat
        THEN
            BEGIN
            CASE arr_index OF
                iprim_key :
                    BEGIN
                    _aux_c40 := 'PK_EQ                                   ';
                    _aux_len := 6
                    END;
                iprim_key_range :
                    BEGIN
                    _aux_c40 := 'PK_RG                                   ';
                    _aux_len := 6
                    END;
                itable_scan :
                    BEGIN
                    _aux_c40 := 'SCAN                                    ';
                    _aux_len := 5
                    END;
                iindex :
                    BEGIN
                    _aux_c40 := 'IX_EQ                                   ';
                    _aux_len := 6
                    END;
                iindex_range :
                    BEGIN
                    _aux_c40 := 'IX_RG                                   ';
                    _aux_len := 6
                    END;
                iis_index :
                    BEGIN
                    _aux_c40 := 'XO_EQ                                   ';
                    _aux_len := 6
                    END;
                iis_index_range :
                    BEGIN
                    _aux_c40 := 'XO_RG                                   ';
                    _aux_len := 6
                    END;
                iis_index_scan :
                    BEGIN
                    _aux_c40 := 'XO_SCAN                                 ';
                    _aux_len := 8
                    END;
                OTHERWISE
                    BEGIN
                    _aux_c40 := '????                                    ';
                    _aux_len := 5
                    END;
                END;
            (*ENDCASE*) 
            b21mp_strat_put  (trans.trBdTcachePtr_gg00, _aux_c40, _aux_len);
            END;
        (*ENDIF*) 
        vclock (_stop_sec, _stop_microsec); (* h.b. PTS 1106105 *)
        vmonitor (trans.trTaskId_gg00, _stop_phys_ios, _stop_suspends,
              _stop_waits);
        _diff_sec      := _stop_sec - start_sec;
        _diff_microsec := _stop_microsec - start_microsec;
        IF  (_stop_microsec < start_microsec)
        THEN
            BEGIN
            _diff_sec      := _diff_sec  - 1;
            _diff_microsec := _diff_microsec + 1000000 ;
            END;
        (*ENDIF*) 
        b21mp_sec_put      (trans.trBdTcachePtr_gg00, _diff_sec);
        b21mp_microsec_put (trans.trBdTcachePtr_gg00, _diff_microsec);
        b21mp_phys_ios_put   (trans.trBdTcachePtr_gg00,
              _stop_phys_ios - start_phys_ios);
        b21mp_suspends_put   (trans.trBdTcachePtr_gg00,
              _stop_suspends - start_suspends);
        b21mp_waits_put      (trans.trBdTcachePtr_gg00,
              _stop_waits - start_waits);
        b21mp_rows_read_put (trans.trBdTcachePtr_gg00, sfp_rows_read);
        b21mp_rows_qual_put (trans.trBdTcachePtr_gg00, sfp_rows_qual);
        b21mp_virt_reads_put (trans.trBdTcachePtr_gg00,
              trans.trRteCommPtr_gg00^.virt_reads + csp_maxint2);
        b21mp_kb_calls_put   (trans.trBdTcachePtr_gg00);
        b21mp_new_sum_put    (trans.trBdTcachePtr_gg00);
        b21m_reset_monitor   (trans.trBdTcachePtr_gg00, NOT _c_reset_sum);
        END;
    (*ENDIF*) 
    IF  g01vtrace.vtrTime_gg00
    THEN
        g04statistic_trace (trans, arr_index,
              sfp_rows_read, sfp_rows_qual,
              trans.trRteCommPtr_gg00^.file_record_cnt,
              trans.trRteCommPtr_gg00^.virt_reads + csp_maxint2);
&   IFDEF TRACE
    (*ENDIF*) 
    t01p2int4 (ak_strat, 'rows_read   ', sfp_rows_read
          ,              'rows_qual   ', sfp_rows_qual);
    t01int4   (ak_strat, 'arr_index   ', ord(arr_index));
&   ENDIF
    IF  arr_index IN [ iprim_key, iprim_key_range, iindex, iindex_range,
        iis_index, iis_index_range, itable_scan, iis_index_scan ]
    THEN
        BEGIN
        IF  strat_cnt
        THEN
            reference_array[ arr_index ] :=
                  reference_array[ arr_index ] + 1;
        (*ENDIF*) 
        arr_index := succ(arr_index);
        reference_array[ arr_index ] := reference_array[ arr_index ] +
              sfp_rows_read;
        arr_index := succ(arr_index);
        reference_array[ arr_index ] := reference_array[ arr_index ] +
              sfp_rows_qual;
        END;
    (*ENDIF*) 
    END;
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720_initialize (
            VAR m                : tgg_mess_block;
            VAR selrec           : tkb7_select_param;
            VAR gg_strategy      : tgg07_StrategyInfo;
            VAR use_stopkey      : boolean;
            VAR finding_possible : boolean);
 
VAR
      _union_append_all : boolean;
      _key_upd_found    : boolean;
      _in_stack         : tsp_int2;
      _in_cnt           : tsp_int2;
      _curr_col         : tsp_int2;
      _i                : tsp_int4;
      _movelength       : tsp_int4;
      _stratlen         : tsp_int4;
      _my_treeid        : tgg00_FileId;
 
BEGIN
_stratlen := m.mb_st^[ m.mb_qual^.mstrat_pos ].elen_var;
&ifdef trace
t01int4( kb, 'StratInfolen', _stratlen );
&endif
m.mb_strat_len := m.mb_strat_len - _stratlen;
;
IF  ( _stratlen > sizeof( tgg07_StrategyInfo ))
THEN
    _movelength := sizeof( tgg07_StrategyInfo )
ELSE
    _movelength := _stratlen;
(*ENDIF*) 
(* get gg_strategy *)
g10mv ('VKB720',   6,    
      m.mb_strat_size, sizeof( gg_strategy ),
      m.mb_strat^, m.mb_st^[ m.mb_qual^.mstrat_pos ].epos,
      gg_strategy, 1, _movelength,
      m.mb_trns^.trError_gg00);
;
&ifdef trace
IF  ( t01trace( ak_strat ) )
THEN
    a725output_gg_strat( ak_strat, 'gg strategy ', gg_strategy, _stratlen )
ELSE
    a725output_gg_strat( kb, 'gg strategy ', gg_strategy, _stratlen );
(*ENDIF*) 
&endif
IF  ( gg_strategy.str_strategy = strat_undecided )
THEN
    m.mb_trns^.trError_gg00 := e_unknown_strategy;
(*ENDIF*) 
;
IF  ( _stratlen = STRATEGY_START_MXGG07 )
THEN
    (* strat_more_then_one *)
    FOR _i := 0 TO MAX_COLPOSARR_IDX_GG07 DO
        BEGIN
        gg_strategy.str_key_in_range.skir_keystart[ _i ] := 0;
        gg_strategy.str_key_in_range.skir_keystop[ _i ]  := 0
        END;
    (*ENDFOR*) 
(*ENDIF*) 
;
_union_append_all := false;
;
m.mb_trns^.trRteCommPtr_gg00^.file_root       := NIL_PAGE_NO_GG00;
m.mb_trns^.trRteCommPtr_gg00^.file_record_cnt := 1;
&IFDEF TRACE
t01int4 (kb, 'str_union_ki', gg_strategy.str_union_kind);
&ENDIF
IF  gg_strategy.str_result_id.fileTfnTemp_gg00 in [ ttfnUnion_egg00, ttfnUnionIntersect_egg00 ]
THEN
    s10fil( sizeof( selrec.selr_selectbuffer.result.info ),
          selrec.selr_selectbuffer.result.info, 1, sizeof( tsp_key ), chr( 0 ));
(*ENDIF*) 
selrec.selr_intersect_id := b01niltree_id;
finding_possible         := gg_strategy.str_res_possible;
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    IF  ( gg_strategy.str_union_kind >= cgg_union_select )
    THEN
        (* *** a combined UNION-SELECT-command *** *)
        BEGIN
        gg_strategy.str_union_kind    := gg_strategy.str_union_kind - cgg_union_select;
        _union_append_all := gg_strategy.str_union_kind >= cgg_union_append;
        IF  ( _union_append_all )
        THEN
            gg_strategy.str_union_kind := gg_strategy.str_union_kind - cgg_union_append;
        (*ENDIF*) 
        selrec.selr_isall := gg_strategy.str_union_kind > 3;
        IF  ( selrec.selr_isall )
        THEN
            gg_strategy.str_union_kind := gg_strategy.str_union_kind - 3;
        (*ENDIF*) 
        selrec.selr_isunion     := gg_strategy.str_union_kind = cgg_union_byte;
        selrec.selr_isexcept    := gg_strategy.str_union_kind = cgg_except_byte;
        selrec.selr_isintersect := gg_strategy.str_union_kind = cgg_intersect_byte;
        IF  ( selrec.selr_isintersect )
        THEN
            BEGIN
            selrec.selr_countresult                   := 0;
            selrec.selr_intersect_id                  := gg_strategy.str_result_id;
            selrec.selr_intersect_id.fileTfnTemp_gg00 := ttfnUnionIntersect_egg00;
            selrec.selr_intersect_id.fileRoot_gg00    := NIL_PAGE_NO_GG00;
            b01tcreate_file (m.mb_trns^, selrec.selr_intersect_id);
            END
        ELSE
            selrec.selr_countresult := gg_strategy.str_foundresults;
        (*ENDIF*) 
        selrec.selr_key_cnt_offs := gg_strategy.str_union_key_cnt_offs;
        selrec.selr_union_select := true;
&       IFDEF TRACE
        t01p2int4 (kb, 'countresult ', selrec.selr_countresult
              ,        'key_cnt_offs', selrec.selr_key_cnt_offs);
        t01bool2  (kb, 'isunion     ', selrec.selr_isunion
              ,        'isexcept    ', selrec.selr_isexcept);
        t01bool2  (kb, 'isintersect ', selrec.selr_isintersect
              ,        'isall       ', selrec.selr_isall);
&       ENDIF
        END
    ELSE
        BEGIN
        (* gg_strategy.str_union_kind < cgg_union_select *)
        _union_append_all        :=
              ( gg_strategy.str_union_kind >= cgg_union_append );
        selrec.selr_countresult  := gg_strategy.str_foundresults;
        selrec.selr_isunion      := false;
        selrec.selr_isexcept     := false;
        selrec.selr_isintersect  := false;
        selrec.selr_isall        := false;
        selrec.selr_key_cnt_offs := 0;
        selrec.selr_union_select := false;
        IF  (( m.mb_type = m_update ) AND ( m.mb_type2 = mm_qual ))
        THEN
            BEGIN
            _key_upd_found  := false;
            _curr_col       := m.mb_qual^.mcol_pos;
            WHILE ( NOT _key_upd_found ) AND
                  ( _curr_col < m.mb_qual^.mcol_pos + m.mb_qual^.mcol_cnt )
                  DO
                BEGIN
                IF  ( m.mb_st^ [ _curr_col ].etype = st_fixkey ) OR
                    ( m.mb_st^ [ _curr_col ].etype = st_varkey )
                THEN
                    _key_upd_found := true
                ELSE
                    _curr_col := _curr_col + 1;
                (*ENDIF*) 
                END;
            (*ENDWHILE*) 
            IF  ( _key_upd_found )
            THEN
                BEGIN
                g04build_temp_tree_id( selrec.selr_intersect_id, m.mb_trns^ );
                selrec.selr_intersect_id.fileTfnTemp_gg00 :=
                      ttfnKeyUpdate_egg00;
                b01treset_file( m.mb_trns^, selrec.selr_intersect_id );
                END
            (*ENDIF*) 
            END
        (*ENDIF*) 
        END;
    (*ENDIF*) 
(*ENDIF*) 
selrec.selr_resf_id        := gg_strategy.str_result_id;
IF  (  NOT a71is_duplicate_avoidance( gg_strategy,
    gg_strategy.str_strategy, gg_strategy.str_raw ))
THEN
    selrec.selr_distinct := gg_strategy.str_distinc
ELSE
    selrec.selr_distinct := no_distinct;
(*ENDIF*) 
selrec.selr_distinct_bytes :=
      ( gg_strategy.str_ordering OR ( gg_strategy.str_union_kind <> 0 ));
selrec.selr_one_result     := false;
selrec.selr_union          := gg_strategy.str_union_kind <> 0;
selrec.selr_cnt_outer_join := 0;
selrec.selr_group_count    := selrec.selr_countresult;
selrec.selr_tree_pos.tpsPno_gg00 := NIL_PAGE_NO_GG00;
selrec.selr_use_rowno      := gg_strategy.str_use_rowno;
selrec.selr_no_warn8_sort  := true;
selrec.selr_fulfilled      := false;
selrec.selr_act_cntresult  := 0;
selrec.selr_all_recursive  := gg_strategy.str_all_files;
FOR _i := 1 TO ckb7_maxdistinctfiles DO
    selrec.selr_disrootarr[ _i ].dfi_root := NIL_PAGE_NO_GG00;
(*ENDFOR*) 
&IFDEF TRACE
t01bool   (kb, 'selr_union_s', selrec.selr_union_select);
t01p2int4 (kb, 'union_kind  ', gg_strategy.str_union_kind
      ,        'count_res   ', selrec.selr_countresult);
&ENDIF
IF  m.mb_trns^.trError_gg00 = e_ok
THEN
    IF  ( m.mb_type = m_insert_select )
    THEN
        WITH m.mb_data^.mbp_info DO
            BEGIN
            selrec.selr_resf_id.fileHandling_gg00 :=
                  selrec.selr_resf_id.fileHandling_gg00 + [ hsIntentExcl_egg00 ] -
                  [ hsWithoutLock_egg00, hsConsistentLock_egg00,
                  hsCollisionTest_egg00, hsNoWait_egg00 ];
            (* prevent from checking treeleafnodes *)
            selrec.selr_resf_id.fileLeafNodes_gg00 := cgg_nil_leafnodes;
            (* otherwise tableas.vdnts will not work *)
            selrec.selr_resf_id.fileRoot_gg00 := NIL_PAGE_NO_GG00;
            IF  ( ftsTemp_egg00 in selrec.selr_resf_id.fileType_gg00 ) AND
                ( selrec.selr_resf_id.fileTfn_gg00 = tfnTemp_egg00 )
            THEN
                IF  ( selrec.selr_resf_id.fileTfnTemp_gg00 = ttfnLink_egg00 ) AND
                    ( hsCreateFile_egg00 in selrec.selr_resf_id.fileHandling_gg00 )
                THEN
                    b01tcreate_file( m.mb_trns^, selrec.selr_resf_id );
                (*ENDIF*) 
            (*ENDIF*) 
            IF  ( rb_ins_sel_info [ 1 ] = cgg_ins_sel_nokey )
            THEN
                BEGIN
                selrec.selr_is_nokey  := true;
                selrec.selr_dupl[ 1 ] := csp_defined_byte
                END
            ELSE
                BEGIN
                selrec.selr_is_nokey := false;
                selrec.selr_dupl     := rb_ins_sel_info;
                END;
            (*ENDIF*) 
            (* prevent from checking treeleafnodes *)
            m.mb_qual^.mtree.fileLeafNodes_gg00 := cgg_nil_leafnodes;
            g10mv3 ('VKB720',   7,    
                  m.mb_strat_size, sizeof(_my_treeid),
                  m.mb_strat^,
                  m.mb_st^[ m.mb_qual^.mstrat_pos ].epos,
                  _my_treeid, 1, mxgg_treeid, m.mb_trns^.trError_gg00);
            ;
            IF  ( m.mb_type                  = m_insert_select ) AND
                ( _my_treeid.fileTfn_gg00     = tfnTemp_egg00  ) AND
                (* PTS 1119178 E.Z. *)
                ( _my_treeid.fileTfnTemp_gg00 = ttfnTempTable_egg00 ) AND
                selrec.selr_is_nokey
            THEN (* insert_select into temp table *)
                rb_into_temp := true;
            (*ENDIF*) 
            END
        (*ENDWITH*) 
    ELSE
        (* m.mb_type <> m_insert_select *)
        BEGIN
        selrec.selr_is_nokey := false;
        IF  ( m.mb_type = m_update ) OR
            ( m.mb_type = m_delete )
        THEN
            (* prevent from checking treeleafnodes *)
            (* during mass-changing command        *)
            m.mb_qual^.mtree.fileLeafNodes_gg00 := cgg_nil_leafnodes;
        (*ENDIF*) 
        END;
    (*ENDIF*) 
(*ENDIF*) 
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    BEGIN
    (* h.b. PTS 1001366 *)
    (* PTS 1104018 E.Z. *)
    k720_maxresult_get( m.mb_data^.mbp_buf, gg_strategy.str_maxresults,
          selrec.selr_maxresult, m.mb_trns^.trError_gg00 );
    selrec.selr_subquery       := ( gg_strategy.str_maxresults = cgg_subquery_one_record );
    selrec.selr_oracle_selinto := ( gg_strategy.str_maxresults = cgg_one_record_at_most_oracle );
    selrec.selr_keyl     := gg_strategy.str_key_len;
    selrec.selr_recl     := gg_strategy.str_rec_len;
    g10fil1 ('VKB720',   8,    
          sizeof( selrec.selr_selectbuffer.result.buf ),
          selrec.selr_selectbuffer.result.buf, 1,
          selrec.selr_recl, csp_defined_byte, m.mb_trns^.trError_gg00);
    selrec.selr_selectbuffer.result.recLen_gg00          := 0;
    selrec.selr_selectbuffer.result.recKeyLen_gg00       := 0;
    selrec.selr_selectbuffer.result.recVarcolOffset_gg00 := 0;
    selrec.selr_selectbuffer.result.recVarcolCnt_gg00    := 0;
    END;
(*ENDIF*) 
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    BEGIN
    IF  ( m.mb_type   = m_select )
        AND
        ( gg_strategy.str_strategy <> strat_catalog )
        AND
        (( m.mb_type2 = mm_first_join_select ) OR
        ( m.mb_type2 = mm_with_join )           )
    THEN
        kb720new_stpos( gg_strategy );
    (*ENDIF*) 
    IF  NOT
        (( gg_strategy.str_strategy = strat_catalog ) OR
        ( gg_strategy.str_strategy in a70glob_fetch_strats ) OR
        NOT finding_possible )
    THEN
        (* in other cases made in AK, because it is necessary *)
        (* for emessbuf used by FETCH *)
        g04inbetween_change( m, finding_possible );
    (*ENDIF*) 
    IF  ( gg_strategy.str_strategy in
        [ strat_key_in, strat_key_equal_sub, strat_key_range_sub,
        strat_more_than_one,
        strat_catalog,
        strat_join_viewkey,   strat_join_all_keys_equal,
        strat_join_key_equal, strat_join_key_next,
        strat_join_inv,       strat_join_key_range,
        strat_join_all_inv_equal, strat_join_inv_range] )
    THEN
        BEGIN
        selrec.selr_startkey.len := 0;
        selrec.selr_stopkey.len  := 0;
        use_stopkey              := false
        END
    ELSE
        (* gg_strategy.str_strategy in [strat_key_equal, strat_key_range,
              strat_sinv_in, strat_sinv_in_sub, strat_sinv_range,
              strat_minv_range, strat_minv_range_sub, strat_minv_in,
              strat_sinv_intersect, strat_sinv_merge_intersect,
              strat_sinv_ordered, strat_minv_ordered,
              strat_undecided,
              alle FETCH-Strategien] *)
        BEGIN
        _in_stack := 0;
        _in_cnt   := 0;
        g04find_in_stack( m, gg_strategy.str_key_in_range.skir_keystart,
              _in_stack, _in_cnt );
        IF  ( _in_stack = 0 )
        THEN
            g04find_in_stack( m, gg_strategy.str_key_in_range.skir_keystop,
                  _in_stack, _in_cnt );
        (*ENDIF*) 
        use_stopkey := true;
        g04limitprimkeys( m, gg_strategy.str_key_in_range.skir_keystart,
              selrec.selr_startkey, gg_strategy.str_key_in_range.skir_keystop,
              selrec.selr_stopkey, use_stopkey, _in_stack, -_in_cnt );
        END;
    (*ENDIF*) 
    selrec.selr_append_all := _union_append_all;
    END;
&ifdef trace
(*ENDIF*) 
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    (* PTS 1000354 E.Z. *)
    IF  ( t01trace (kb) )
    THEN
        BEGIN
        IF  ( selrec.selr_append_all )
        THEN
            t01bool (kb, 'APPEND ALL  ', selrec.selr_append_all);
        (*ENDIF*) 
        t01treeid (kb, 'resf_id     ', selrec.selr_resf_id);
        t01lkey   (kb, selrec.selr_startkey);
        IF  ( use_stopkey )
        THEN
            BEGIN
            t01int4 (kb, 'use_stopkey ', 1);
            t01lkey (kb, selrec.selr_stopkey);
            END
        (*ENDIF*) 
        END;
&   endif
    (*ENDIF*) 
(*ENDIF*) 
selrec.selr_join_with_func := false;
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    IF  ( m.mb_qual^.mresqual_cnt > 0 )
        AND
        ( m.mb_type = m_select )
        AND
        ( m.mb_type2 = mm_with_join )
    THEN
        IF  ( m.mb_st^[ m.mb_qual^.mresqual_pos ].etype = st_jump_output )
        THEN
            BEGIN
            _i := m.mb_qual^.mresqual_pos + 1;
            WHILE ( _i < m.mb_st^[ m.mb_qual^.mresqual_pos ].epos +
                  m.mb_qual^.mresqual_pos - 2 ) DO
                WITH  m.mb_st^[ _i ] DO
                    BEGIN
                    _i := succ ( _i );
                    IF  ( etype = st_func )
                    THEN
                        BEGIN
                        (* *** mm_with_functions *** *)
                        m.mb_type2 := mm_with_functions;
                        selrec.selr_join_with_func := true;
                        IF  ( eop_func in [
                            op_f_all_count
                            ,              op_f_avg
                            ,              op_f_max
                            ,              op_f_min ] )
                        THEN
                            selrec.selr_one_result := true;
                        (*ENDIF*) 
                        END;
                    (*ENDIF*) 
                    END;
                (*ENDWITH*) 
            (*ENDWHILE*) 
            END;
        (*ENDIF*) 
    (*ENDIF*) 
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720_single_select (VAR m : tgg_mess_block);
 
VAR
      _selrec       : tkb7_select_param;
      _getrec_dummy : tkb7_get_param;
 
BEGIN
(* looks a little bit silly, but getrec and selrec *)
(* are very hugh (>56K), so it's better to create  *)
(* them only when necessary and not every time in  *)
(* k05functions.                                   *)
k720_select( m, _getrec_dummy, _selrec );
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720_test_subquery (
            VAR m   : tgg_mess_block;
            VAR rec : tgg_rec_buf);
 
VAR
      _set_result : tgg_bd_set_result_record;
      _first_prim : integer;
      _i          : integer;
      _last       : integer;
      _pos        : integer;
      _start      : integer;
      _k          : tgg_lkey;
      _htree_id   : tgg00_FileId;
      _t_tree_pos : tgg00_FilePos;
 
BEGIN
WITH m, mb_qual^ DO
    BEGIN
    _start := mqual_pos;
    _last  := mqual_pos + mqual_cnt - 1;
    REPEAT
        IF  mb_type <> m_update
        THEN
            IF  mb_st^[ _start ].etype = st_jump_output
            THEN
                _start := _start + mb_st^[ _start ].epos - 1;
            (*ENDIF*) 
        (*ENDIF*) 
        _pos  := _start;
&       IFDEF TRACE
        t01p2int4 (ak_strat, 'start       ', _start
              ,        'last        ', _last);
&       ENDIF
        mb_trns^.trError_gg00 := e_ok;
        WHILE _pos <= _last DO
            BEGIN
            _first_prim := _pos;
            WHILE ((_pos < _last) AND
                  NOT (mb_st^[ _pos ].etype in [ st_jump_true,
                  st_jump_false, st_subquery, st_get_subquery,
                  st_output ])) DO
                _pos := succ(_pos);
            (*ENDWHILE*) 
&           IFDEF TRACE
            t01p2int4 (ak_strat, 'first_prim  ', _first_prim
                  ,        'pos         ', _pos);
&           ENDIF
            IF  mb_st^[_pos].etype in [st_subquery, st_get_subquery]
            THEN
                IF  (mb_st^[_pos].etype = st_subquery) AND
                    (mb_st^[_pos].eop = op_get_sub_value)
                THEN
                    k71sub_value_get (mb_trns^, mb_st^[_pos], @(mb_data^.mbp_buf), mb_data_size)
                ELSE
                    BEGIN
                    (* get subquery file ID *)
                    g10mv3 ('VKB720',   9,    
                          mb_data_size, sizeof(_htree_id),
                          mb_data^.mbp_buf, mb_st^[ _pos ].epos,
                          _htree_id, 1, mxgg_treeid,
                          mb_trns^.trError_gg00);
&                   IFDEF TRACE
                    t01site   (ak_strat, 'result_site ', _htree_id.fileResultSite_gg00);
                    t01treeid (ak_strat, 'htree_id    ', _htree_id);
&                   ENDIF
                    IF  mb_trns^.trError_gg00 <> e_ok
                    THEN
                        (* break through while loop *)
                        _pos := _last + 1
                    ELSE
                        IF  mb_st^[_pos].etype = st_subquery
                        THEN
                            BEGIN
                            _k.len := mxsp_key;
                            g10fil ('VKB720',  10,    
                                  sizeof(_k.k), _k.k, 1, _k.len, chr(255),
                                  mb_trns^.trError_gg00);
                            WITH _set_result DO
                                BEGIN
                                bd_key_check_len := 0;
                                bd_max_rec_cnt   := 1;
                                bd_max_fill_len  := mxsp_buf;
                                bd_next          := true;
                                bd_drop_page     := false;
                                END;
                            (*ENDWITH*) 
                            _t_tree_pos.tpsPno_gg00 := NIL_PAGE_NO_GG00;
                            IF  (mb_trns^.trError_gg00 <> e_move_error)
                            THEN
                                b07cprev_record (mb_trns^, _htree_id, _k,
                                      _set_result, _t_tree_pos, rec.buf);
                            (*ENDIF*) 
                            IF  ((mb_trns^.trError_gg00 = e_ok) OR
                                (mb_trns^.trError_gg00 = e_key_not_found))
                            THEN
                                BEGIN
                                g10mv2 ('VKB720',  11,    
                                      sizeof(_htree_id), mb_data_size,
                                      _htree_id, 1,
                                      mb_data^.mbp_buf, mb_st^[ _pos ].epos,
                                      mxgg_treeid,
                                      mb_trns^.trError_gg00);
                                mb_st^[ _pos ].elen_var :=
                                      mb_st^[ _pos ].elen_var + rec.keylen;
                                IF  ((mb_st^[ _pos ].ecol_tab[ 1 ] = chr(1)) AND
                                    (mb_st^[ _pos ].ecol_tab[ 2 ] = chr(1)))
                                THEN (* exists *)
                                    BEGIN
                                    mb_st^[ _pos ].etype := st_bool;
                                    mb_st^[ _pos ].eop   := op_none;
                                    mb_st^[ _pos ].epos  := cgg_is_true
                                    END
                                ELSE
                                    IF  rec.info[ 1 ] = chr(255)
                                    THEN
                                        (* NULL value in record *)
                                        mb_st^[ _pos ].elen_var := - mb_st^[ _pos ].elen_var
                                    (*ENDIF*) 
                                (*ENDIF*) 
                                END
                            ELSE
                                IF  mb_trns^.trError_gg00 = e_no_prev_record
                                THEN
                                    BEGIN
                                    FOR _i := _first_prim TO _pos - 1 DO
                                        mb_st^[ _i ].etype := st_dummy;
                                    (*ENDFOR*) 
                                    mb_st^[ _pos ].etype := st_bool;
                                    mb_st^[ _pos ].eop  := op_none;
                                    mb_st^[ _pos ].epos := cgg_is_true;
                                    IF  mb_st^[ _pos ].ecol_tab[ 2 ] = chr(1)
                                        (* any, exists *)
                                    THEN
                                        mb_st^[ _pos ].epos := cgg_is_false
                                    ELSE
                                        IF  mb_st^[_pos].ecol_tab[1] = chr(0)
                                            (* neither any nor all *)
                                        THEN
                                            mb_st^[_pos].epos := cgg_is_undef;
                                        (*ENDIF*) 
                                    (*ENDIF*) 
                                    IF  _pos < _last
                                    THEN
                                        IF  mb_st^[ _pos + 1 ].eop = op_not
                                        THEN
                                            BEGIN
                                            mb_st^[ _pos + 1 ].eop := op_none;
                                            WITH mb_st^[ _pos ] DO
                                                IF  epos = cgg_is_true
                                                THEN
                                                    epos := cgg_is_false
                                                ELSE
                                                    IF  epos = cgg_is_false
                                                    THEN
                                                     epos := cgg_is_true;
                                                    (*ENDIF*) 
                                                (*ENDIF*) 
                                            (*ENDWITH*) 
                                            IF  mb_st^[_pos + 1].etype = st_op
                                            THEN
                                                mb_st^[ _pos + 1 ].etype :=
                                                      st_dummy
                                            (*ENDIF*) 
                                            END
                                        (*ENDIF*) 
                                    (*ENDIF*) 
                                    END;
                                (*ENDIF*) 
                            (*ENDIF*) 
                            IF  mb_trns^.trError_gg00 <> e_move_error
                            THEN
                                mb_trns^.trError_gg00 := e_ok
                            (*ENDIF*) 
                            END;
                        (*ENDIF*) 
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
            (*ENDIF*) 
            _pos := succ(_pos)
            END;
        (*ENDWHILE*) 
        _start := mresqual_pos;
        _last  := mresqual_pos + mresqual_cnt - 1;
    UNTIL
        (_pos > mresqual_pos);
    (*ENDREPEAT*) 
    END
(*ENDWITH*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      k720apply_aggr_func (
            VAR funct_fields : tgg_aggr_descr_rec;
            VAR listkey      : tgg_lkey;
            VAR lbuf         : tsp_buf;
            one_list_only    : boolean;
            VAR e            : tgg_basis_error);
 
VAR
      ix, iy, iz   : integer;
      f_len        : tsp_int2;
      f_pos        : tsp_int2;
      length       : integer;
      ret          : tsp_num_error;
      l_key        : tsp_key;
      add_count    : tsp_int4;
 
BEGIN
&IFDEF TRACE
t01int4 (ak_strat, 'prim count  ', funct_fields.agg_prim_key_cnt);
&ENDIF
g10mv6 ('VKB720',  12,    
      sizeof(listkey.k), sizeof(l_key), listkey.k, 1,
      l_key, 1, listkey.len, e);
IF  e = e_ok
THEN
    FOR ix := 1 TO funct_fields.agg_cnt DO
        WITH funct_fields, agg_field_descr[ ix ] DO
            IF  field_sum_flag
            THEN
                BEGIN
                IF  (field_function in [ op_f_sum, op_f_avg ])
                THEN
                    add_count := agg_prim_key_cnt
                ELSE
                    add_count := 1;
                (*ENDIF*) 
                f_pos := field_rec_pos;
                IF  (field_rec_len = 0)
                THEN
                    f_len := (listkey.len - f_pos)
                ELSE
                    f_len := field_rec_len - 1;
                (*ENDIF*) 
                IF  field_is_descen
                THEN
                    FOR iy := f_pos TO (f_pos + f_len) DO
                        l_key[ iy ] :=
                              chr (255 - ord (listkey.k[ iy ]));
                    (*ENDFOR*) 
                (*ENDIF*) 
                IF  (lbuf[ result_out_pos ] = csp_undef_byte) OR
                    one_list_only
                THEN
                    BEGIN
                    lbuf[ result_out_pos ]   := csp_defined_byte;
                    lbuf[ result_out_pos+1 ] := cgg_zero_exponent;
                    END;
                (*ENDIF*) 
                iz  := 1;
                ret := num_ok;
                WHILE (iz <= add_count) AND (ret = num_ok) DO
                    BEGIN
                    s51add (lbuf,
                          result_out_pos+1, result_out_len-1,
                          l_key,
                          f_pos+1, f_len,
                          lbuf, result_out_pos+1,
                          csp_fixed,
                          csp_float_frac,
                          length, ret);
                    IF  ret <> num_ok
                    THEN
                        BEGIN
                        lbuf[ result_out_pos+1 ] := chr(255);
                        FOR iy := 1 TO 9 DO
                            lbuf[ result_out_pos+1+iy ] :=
                                  chr(153)
                        (*ENDFOR*) 
                        END;
                    (*ENDIF*) 
                    iz := succ(iz);
                    END;
                (*ENDWHILE*) 
                END;
            (*ENDIF*) 
        (*ENDWITH*) 
    (*ENDFOR*) 
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      kb720sel_first_part (
            VAR m           : tgg_mess_block;
            VAR selrec      : tkb7_select_param;
            VAR selfields   : tgg_select_fields_param;
            VAR gg_strategy : tgg07_StrategyInfo;
            VAR select_vars : tgg07_K720selectVars);
 
VAR
      _ix                : tsp_int2;
      _start             : tsp_int2;
      _stop              : tsp_int2;
      _strat_col         : tsp_int2;
      _aux_mresqual_pos  : tsp_int2;
      _aux_mresqual_cnt  : tsp_int2;
      _aux_mqual_pos     : tsp_int2;
      _aux_mqual_cnt     : tsp_int2;
 
BEGIN
select_vars.sv_dis_file_cnt      := 0;
select_vars.sv_call_do_avg       := false;
select_vars.sv_call_later_output := false;
select_vars.sv_trunc_part2       :=
      ( m.mb_type2 <> mm_first_join_select ) AND
      ( m.mb_type2 <> mm_with_join );
;
IF  ( m.mb_qual^.mqual_pos > 0 )
THEN
    select_vars.sv_no_oj_destroy_f :=
          ( m.mb_st^[ m.mb_qual^.mqual_pos ].eop = op_outer_join ) AND NOT
          ( select_vars.sv_trunc_part2 AND (m.mb_type2 <> mm_join_with_last_tab ))
ELSE
    select_vars.sv_no_oj_destroy_f := false;
(*ENDIF*) 
IF  ( m.mb_type2 = mm_join_with_last_tab )
THEN
    m.mb_type2  := mm_with_join;
(*ENDIF*) 
select_vars.sv_tree  := m.mb_qual^.mtree;
select_vars.sv_type  := m.mb_type;
select_vars.sv_type2 := m.mb_type2;
;
g04init_select_fields( selfields, @m.mb_data^.mbp_buf, m.mb_data_size,
      m.mb_work_st, m.mb_work_st_max, m.mb_workbuf, m.mb_workbuf_size,
      m.mb_qual^.msqlmode );
selfields.sfp_bd_mess_type    := m.mb_type;
selfields.sfp_bd_mess2_type   := mm_first;
selfields.sfp_replicated      := m.mb_replicated;
selfields.sfp_result_wanted   := true;
selfields.sfp_oj_spec         := ckb7_ojoin_none;
IF  ( m.mb_type2 in [ mm_join_with_last_tab, mm_with_join ] )
THEN
    (* *** no value - address in vkb71 (right outer join!) *** *)
    selfields.sfp_is_first_record := false;
(*ENDIF*) 
;
selrec.selr_resf_id.fileRoot_gg00 := NIL_PAGE_NO_GG00;
&ifdef trace
t01qual( kb, m.mb_qual^ );
&endif
k720_initialize( m, selrec, gg_strategy, selfields.sfp_bd_use_stopkey,
      select_vars.sv_finding_possible );
;
&ifdef trace
t01bool( kb, 'result possi', select_vars.sv_finding_possible );
t01basis_error( kb,'trError     ', m.mb_trns^.trError_gg00 );
&endif
select_vars.sv_global_strat     := gg_strategy.str_strategy;
;
selfields.sfp_bd_inv_only := gg_strategy.str_qual_kind;
(* PTS 1112079 E.Z. *)
selfields.sfp_check_for_result := gg_strategy.str_search_first;
;
selrec.selr_resrec_maxlen  := selfields.sfp_resrec_maxlen;
selrec.selr_intern_dist    := false;
select_vars.sv_file_to_drop     := false;
;
IF  ( m.mb_trns^.trError_gg00 = e_ok )
THEN
    BEGIN
    g04build_temp_tree_id( selrec.selr_distinct_id, m.mb_trns^ );
    selrec.selr_distinct_id.fileTfnTemp_gg00 := ttfnDistinct_egg00;
    selrec.selr_distinct_id.fileTempCnt_gg00 := 0;
    IF  ( m.mb_type = m_update ) AND
        ( gg_strategy.str_strategy in a70glob_inv_strats )
    THEN
        IF  ( selrec.selr_intersect_id.fileName_gg00 = cgg_zero_fn )
            OR
            (( selrec.selr_intersect_id.fileName_gg00 <> cgg_zero_fn ) AND
            ( selrec.selr_intersect_id.fileTfnTemp_gg00 <> ttfnKeyUpdate_egg00 ))
        THEN
            BEGIN
            (* mmult_pos: descriptions of indexes columns to be updated *)
            _start := m.mb_qual^.mmult_pos;
            _stop  := m.mb_qual^.mmult_pos + m.mb_qual^.mmult_cnt;
            _ix    := 0;
            WHILE ( _ix <= gg_strategy.str_inv_in_range.siir_startcnt - 1 )
                  AND
                  ( NOT selrec.selr_intern_dist ) DO
                BEGIN
                _strat_col :=
                      abs( gg_strategy.str_inv_in_range.siir_invstart[ _ix ] );
                IF  ( _strat_col > 0 )
                THEN
                    kb720check_upd( m, selrec, _strat_col, _start, _stop );
                (*ENDIF*) 
                _ix := succ( _ix );
                END;
            (*ENDWHILE*) 
            _ix    := 0;
            WHILE ( _ix <= gg_strategy.str_inv_in_range.siir_stopcnt - 1 ) AND
                  ( NOT selrec.selr_intern_dist ) DO
                BEGIN
                _strat_col := abs( gg_strategy.str_inv_in_range.siir_invstop[ _ix ] );
                IF  ( _strat_col > 0 )
                THEN
                    kb720check_upd( m, selrec, _strat_col, _start, _stop );
                (*ENDIF*) 
                _ix := succ( _ix );
                END;
            (*ENDWHILE*) 
            END;
        (*ENDIF*) 
    (*ENDIF*) 
    IF  (( gg_strategy.str_cnt_strat > 1 ) AND
        ( selrec.selr_distinct = no_distinct ) AND
        ( m.mb_type <> m_delete ))
        OR
        selrec.selr_intern_dist
    THEN
        BEGIN
        (* there's no other distinct handling, so we must do it *)
        b01tcreate_file( m.mb_trns^, selrec.selr_distinct_id );
        selrec.selr_intern_dist := ( m.mb_trns^.trError_gg00 = e_ok );
        END;
    (*ENDIF*) 
    IF  ( m.mb_trns^.trError_gg00   =  e_ok ) AND
        ( m.mb_trns^.trIndex_gg00 = cgg_nil_transindex )
    THEN
        IF  NOT ( gg_strategy.str_strategy in [ strat_catalog ] )
        THEN
            m.mb_trns^.trError_gg00 := e_nil_transindex;
        (*ENDIF*) 
    (*ENDIF*) 
    IF  ( m.mb_trns^.trError_gg00 = e_ok )
    THEN
        BEGIN
        IF  NOT
            ( gg_strategy.str_strategy in a70glob_fetch_strats )
            AND NOT
            (
            ( m.mb_type  IN [ m_update, m_delete      ] ) AND
            ( m.mb_type2 IN [ mm_qual,  mm_qual_no_opt] )
            )
            AND NOT ( m.mb_type = m_insert_select )
        THEN
            BEGIN
            IF  ( selrec.selr_resf_id.fileTfnTemp_gg00 = ttfnInto_egg00 ) AND
                ( selrec.selr_resf_id.fileTfn_gg00     = tfnTemp_egg00 )
            THEN
                BEGIN
                IF  ( selrec.selr_maxresult = 0 ) (* SELECT INTO *)
                    AND
                    ( gg_strategy.str_strategy <> strat_more_than_one )
                    AND
                    (
                    (( m.mb_type2=mm_with_functions ) AND
                    ( selrec.selr_keyl = 4 ))
                    OR
                    (* no DISTINCT, no ORDER, key of result set is result counter *)
                    ( NOT ( m.mb_type2 in [ mm_with_functions, mm_with_join ] )
                    AND ( selrec.selr_distinct = no_distinct ))
                    OR
                    gg_strategy.str_corr_single
                    )
                THEN
                    selrec.selr_one_result := true;
                (*ENDIF*) 
                END
            ELSE
                IF  (( selrec.selr_countresult  = 0 ) OR
                    selrec.selr_union_select )
                    AND
                    ( selrec.selr_resf_id.fileRoot_gg00 = NIL_PAGE_NO_GG00 )
                    AND
                    ( hsCreateFile_egg00 in selrec.selr_resf_id.fileHandling_gg00 )
                THEN
                    BEGIN
                    b01tcreate_file( m.mb_trns^, selrec.selr_resf_id );
&                   IFDEF TRACE
                    t01basis_error( kb,'trError     ', m.mb_trns^.trError_gg00 );
&                   ENDIF
                    IF  ( m.mb_trns^.trError_gg00 = e_duplicate_filename )
                    THEN
                        IF  ( ftsTemp_egg00 in selrec.selr_resf_id.fileType_gg00    ) AND
                            ( selrec.selr_resf_id.fileTfn_gg00      = tfnTemp_egg00 ) AND
                            ( selrec.selr_resf_id.fileTfnTemp_gg00 <> ttfnInto_egg00 )
                        THEN
                            b01empty_file( m.mb_trns^, selrec.selr_resf_id );
                        (*ENDIF*) 
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
            (*ENDIF*) 
            IF  ( m.mb_trns^.trError_gg00 = e_ok )
            THEN
                select_vars.sv_file_to_drop := true;
            (*ENDIF*) 
            END
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    select_vars.sv_one_result := selrec.selr_one_result;
    select_vars.sv_keylen     := selrec.selr_keyl;
    ;
    selrec.selr_count_all     := false;
    selrec.selr_count_bd      := false;
    selrec.selr_union_select  := selrec.selr_append_all;
    ;
    IF  ( m.mb_type2 = mm_with_functions ) AND
        ( m.mb_trns^.trError_gg00 = e_ok )
    THEN
        BEGIN
        selrec.selr_count_all :=
              NOT (( selrec.selr_keyl > mxgg_rescnt ) OR
              ( gg_strategy.str_cnt_strat > 1 )) AND
              ( abs(gg_strategy.str_maxresults) < cgg_valid_rowno_pos );
        (*rowno*)
        IF  ( selrec.selr_join_with_func )
        THEN
            BEGIN
            _aux_mresqual_pos       := m.mb_qual^.mresqual_pos;
            _aux_mresqual_cnt       := m.mb_qual^.mresqual_cnt;
            _aux_mqual_pos          := m.mb_qual^.mqual_pos;
            _aux_mqual_cnt          := m.mb_qual^.mqual_cnt;
            m.mb_qual^.mqual_pos    := m.mb_qual^.mresqual_pos;
            m.mb_qual^.mqual_cnt    := m.mb_qual^.mresqual_cnt;
            m.mb_qual^.mresqual_pos := 0;
            m.mb_qual^.mresqual_cnt := 0;
            (* *** d_keylen (vak684)  *** *)
            selrec.selr_keyl        :=
                  m.mb_st^[ m.mb_qual^.mstrat_pos + 1 ].ecol_pos;
            select_vars.sv_keylen        := selrec.selr_keyl;
            END;
        (*ENDIF*) 
        kb720distinct_files( m, selrec, select_vars.sv_dis_file_cnt,
              select_vars.sv_call_do_avg, select_vars.sv_call_later_output );
        IF  ( selrec.selr_join_with_func )
        THEN
            BEGIN
            m.mb_qual^.mresqual_pos := _aux_mresqual_pos;
            m.mb_qual^.mresqual_cnt := _aux_mresqual_cnt;
            m.mb_qual^.mqual_pos    := _aux_mqual_pos;
            m.mb_qual^.mqual_cnt    := _aux_mqual_cnt;
            selrec.selr_keyl        := gg_strategy.str_key_len;
            select_vars.sv_keylen   := selrec.selr_keyl;
            END;
        (*ENDIF*) 
        IF  ( selrec.selr_count_all )
        THEN
            IF  ( m.mb_st^[ m.mb_qual^.mqual_pos ].epos = m.mb_qual^.mqual_cnt ) AND
                ( NOT selrec.selr_join_with_func )
            THEN
                selrec.selr_count_bd := true;
            (*ENDIF*) 
        (*ENDIF*) 
        IF  ( gg_strategy.str_cnt_strat = 1 )
        THEN
            BEGIN
            (* PTS 1000718 E.Z. *)
            IF  ( selrec.selr_keyl = mxgg_rescnt )
                AND
                ( gg_strategy.str_strategy <> strat_more_than_one )
            THEN
                selrec.selr_one_result := true;
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    m.mb_type2 := select_vars.sv_type2;
    IF  ( gg_strategy.str_use_subquery = normal_subquery ) AND
        ( m.mb_trns^.trError_gg00 = e_ok )
    THEN
        k720_test_subquery( m, selrec.selr_selectbuffer.buf_rec );
    (*ENDIF*) 
    IF  ( m.mb_type   =  m_select )            AND
        ( m.mb_type2 <> mm_first_join_select ) AND
        ( m.mb_type2 <> mm_with_join )         AND
        ( m.mb_qual^.mtree.fileTfn_gg00 <> tfnTemp_egg00 ) AND
        ( m.mb_trns^.trError_gg00 =  e_ok )                AND
        (( hsTempLock_egg00 in m.mb_qual^.mtree.fileHandling_gg00 ) OR
        ( hsPermLock_egg00 in m.mb_qual^.mtree.fileHandling_gg00 ))
    THEN
        BEGIN
        k53perm_temp_lock( m.mb_trns^,
              m_lock, lckTabShare_egg00,
              m.mb_qual^.mtree.fileHandling_gg00 - [ hsCollisionTest_egg00 ],
              m.mb_qual^.mtree.fileTabId_gg00,
              selrec.selr_invkey (* dummy *) );
        ;
        IF  ( m.mb_trns^.trError_gg00 = e_wait_for_lock_release )
        THEN
            k53wait( m.mb_trns^, m.mb_type, m.mb_type2 );
        (*ENDIF*) 
        IF  (
            (( hsPermLock_egg00 in m.mb_qual^.mtree.fileHandling_gg00 ) AND
            NOT ( hsIntentExcl_egg00 in m.mb_qual^.mtree.fileHandling_gg00 ))
            OR
            ( hsCollisionTest_egg00 in m.mb_qual^.mtree.fileHandling_gg00 )
            )
        THEN
            m.mb_qual^.mtree.fileHandling_gg00 :=
                  m.mb_qual^.mtree.fileHandling_gg00 + [ hsWithoutLock_egg00 ];
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    END;
(*ENDIF*) 
selfields.sfp_act_cntresult := 1;
END;
 
(*------------------------------*) 
 
PROCEDURE
      kb720sel_last_part (
            VAR m           : tgg_mess_block;
            VAR selrec      : tkb7_select_param;
            VAR getrec      : tkb7_get_param;
            VAR selfields   : tgg_select_fields_param;
            VAR gg_strategy : tgg07_StrategyInfo;
            VAR select_vars : tgg07_K720selectVars);
 
VAR
      _res        : tsp_num_error;
      _aux_error  : tgg_basis_error;
      _set_result : tgg_bd_set_result_record;
 
BEGIN
IF  ( m.mb_type      = m_select )    AND
    ( m.mb_qual^.mresqual_cnt > 0 )  AND (* join with OR *)
    selrec.selr_join_with_func       AND
    selrec.selr_one_result
THEN
    BEGIN
    selrec.selr_recl             := getrec.gi_minfo.n_rec_len;
    selrec.selr_keyl             := getrec.gi_minfo.n_key_len;
    selfields.sfp_act_cntresult := selrec.selr_countresult;
    m.mb_type2              := mm_with_functions;
    select_vars.sv_one_result         := false;
    (* *** d_keylen (vak690)  *** *)
    select_vars.sv_keylen             :=
          m.mb_st^[ m.mb_qual^.mstrat_pos + 1 ].ecol_pos;
    selrec.selr_selectbuffer.result.keylen := select_vars.sv_keylen;
    m.mb_qual^.mqual_pos    := m.mb_qual^.mresqual_pos;
    m.mb_qual^.mqual_cnt    := m.mb_qual^.mresqual_cnt;
    m.mb_qual^.mresqual_pos := 0;
    m.mb_qual^.mresqual_cnt := 0;
    END;
(*ENDIF*) 
IF  ( m.mb_trns^.trError_gg00 = e_enough_resultsets )
THEN
    BEGIN
    m.mb_trns^.trError_gg00 := e_ok;
    IF  ( abs(gg_strategy.str_maxresults) >= cgg_valid_rowno_pos )
        (*rowno*)
    THEN
        m.mb_trns^.trWarning_gg00 := m.mb_trns^.trWarning_gg00 +
              [ warn0_exist, warn12_rowno_used ]
    (*ENDIF*) 
    END;
(*ENDIF*) 
IF  ( selrec.selr_intern_dist )
THEN
    BEGIN
    _aux_error := m.mb_trns^.trError_gg00;
    b01destroy_file( m.mb_trns^, selrec.selr_distinct_id );
    IF  ( _aux_error <> e_ok )
    THEN
        m.mb_trns^.trError_gg00 := _aux_error
    (*ENDIF*) 
    END;
(*ENDIF*) 
IF  ( m.mb_type = m_update ) AND ( m.mb_type2 = mm_qual ) AND
    ( selrec.selr_intersect_id.fileName_gg00 <> cgg_zero_fn )
THEN
    BEGIN
    _aux_error := m.mb_trns^.trError_gg00;
    b01destroy_file( m.mb_trns^, selrec.selr_intersect_id );
    IF  ( _aux_error <> e_ok )
    THEN
        m.mb_trns^.trError_gg00 := _aux_error
    (*ENDIF*) 
    END;
(*ENDIF*) 
IF  ( m.mb_type2 = mm_with_functions )
THEN
    BEGIN
    selrec.selr_countresult := selrec.selr_group_count;
    IF  ( m.mb_trns^.trError_gg00 = e_ok )
    THEN
        BEGIN
        IF  ( selrec.selr_countresult > 0 )
        THEN
            BEGIN
            IF  ( select_vars.sv_call_do_avg )
            THEN
                k721do_avg( m, selrec, select_vars.sv_call_later_output,
                      select_vars.sv_keylen )
            ELSE
                IF  ( select_vars.sv_call_later_output )
                THEN
                    IF  ( NOT selrec.selr_one_result )
                    THEN
                        BEGIN
                        selrec.selr_invkey.len := mxgg_rescnt;
                        selrec.selr_invkey.k[1] := chr(0);
                        selrec.selr_invkey.k[2] := chr(0);
                        selrec.selr_invkey.k[3] := chr(0);
                        selrec.selr_invkey.k[4] := chr(1);
                        b07cget_record( m.mb_trns^, selrec.selr_resf_id,
                              selrec.selr_invkey, selrec.selr_selectbuffer.lbuf );
                        IF  ( m.mb_trns^.trError_gg00 = e_key_not_found ) OR
                            ( m.mb_trns^.trError_gg00 = e_ok )
                        THEN
                            BEGIN
                            m.mb_trns^.trError_gg00 := e_ok;
                            b07cdel_record( m.mb_trns^, selrec.selr_resf_id,
                                  selrec.selr_invkey );
                            IF  ( m.mb_trns^.trError_gg00 = e_ok )
                            THEN
                                BEGIN
                                k721call_later_output( m,
                                      selrec.selr_selectbuffer.lbuf,
                                      select_vars.sv_keylen );
                                b07cadd_record( m.mb_trns^, selrec.selr_resf_id,
                                      selrec.selr_selectbuffer.lbuf );
                                END;
                            (*ENDIF*) 
                            END;
                        (*ENDIF*) 
                        END
                    ELSE
                        k721call_later_output( m, selrec.selr_selectbuffer.lbuf,
                              select_vars.sv_keylen );
                    (*ENDIF*) 
                (*ENDIF*) 
            (*ENDIF*) 
            END
        ELSE
            IF  ((( selrec.selr_distinct <> no_distinct ) AND
                ( select_vars.sv_keylen = mxgg_rescnt + cgg_cdistinct_bytes ))
                OR
                ( select_vars.sv_call_later_output )
                OR
                ( select_vars.sv_keylen = mxgg_rescnt )
                OR
                (( selrec.selr_resf_id.fileTfnTemp_gg00 = ttfnSubquery_egg00 ) AND
                ( selrec.selr_resf_id.fileTfn_gg00      = tfnTemp_egg00 )))
                (* an empty grouped table results in error 100 *)
            THEN
                BEGIN
                k721null_result( m, selrec, selfields,
                      selfields.sfp_act_cntresult - 1,
                      select_vars.sv_call_later_output, select_vars.sv_keylen );
                IF  ( m.mb_trns^.trError_gg00 = e_enough_resultsets )
                THEN
                    m.mb_trns^.trError_gg00 := e_ok;
                (*ENDIF*) 
                END
            ELSE
                selrec.selr_one_result := false;
            (*ENDIF*) 
        (*ENDIF*) 
        IF  ( selrec.selr_one_result AND NOT select_vars.sv_one_result
            AND ( m.mb_trns^.trError_gg00 = e_ok ))
        THEN
            b07cadd_record( m.mb_trns^, selrec.selr_resf_id,
                  selrec.selr_selectbuffer.lbuf )
        (*ENDIF*) 
        END;
    (*ENDIF*) 
    _aux_error := m.mb_trns^.trError_gg00;
    IF  ( select_vars.sv_dis_file_cnt > 0 )
    THEN
        b01prefix_destroy_files( m.mb_trns^, selrec.selr_distinct_id.fileName_gg00,
              mxgg_tempprefix + 1 );
    (*ENDIF*) 
    IF  ( _aux_error <> e_ok )
    THEN
        m.mb_trns^.trError_gg00 := _aux_error;
    (*ENDIF*) 
    selrec.selr_one_result := select_vars.sv_one_result
    END;
(*ENDIF*) 
IF  ( gg_strategy.str_use_rowno AND ( selrec.selr_countresult > 0 ) AND
    ( m.mb_trns^.trError_gg00 = e_ok ))
THEN
    BEGIN
    IF  ( m.mb_type2 = mm_with_join )
    THEN
        k74rowno_position( m, getrec, selrec )
    ELSE
        k721do_rowno( m, selrec );
    (*ENDIF*) 
    END;
(*ENDIF*) 
IF  ( m.mb_trns^.trError_gg00 = e_ok ) AND ( m.mb_type2 <> mm_with_join )
THEN
    BEGIN
    IF  NOT ( gg_strategy.str_strategy in a70glob_fetch_strats )
    THEN
        BEGIN
        IF  ( m.mb_type = m_select ) AND (selrec.selr_keyl > mxgg_rescnt) (* PTS 1113927 *)
        THEN
            b73cmds_count( iins_sorts_rows_ins, selrec.selr_countresult );
        (*ENDIF*) 
        IF  (( selrec.selr_maxresult <> 0 ) (* no SELECT INTO *)
            OR (( selrec.selr_maxresult = 0 ) AND ( m.mb_type = m_update ))
            OR ( gg_strategy.str_maxresults = cgg_subquery_one_record )) (*Subquery*)
        THEN
            BEGIN
            IF  ( m.mb_type <> m_update ) OR
                ( m.mb_qual_len  < mxgg_mb_part1head +
                mxgg_mb_part1_return )
            THEN
                m.mb_qual_len  := mxgg_mb_part1head +
                      mxgg_mb_part1_return;
            (*ENDIF*) 
            IF  ( m.mb_qual^.mtrigger_cnt > 0 )
            THEN
                k62return_trigger( m )
            ELSE
                IF  ( m.mb_type <> m_insert_select )
                THEN
                    BEGIN
                    selrec.selr_resf_id.fileResultSite_gg00 := g01localsite;
                    m.mb_qual^.mr_restree      := selrec.selr_resf_id;
                    END;
                (*ENDIF*) 
            (*ENDIF*) 
            IF  ( selrec.selr_union_select )
            THEN
                BEGIN
                selrec.selr_key_cnt_offs :=
                      selrec.selr_key_cnt_offs + selrec.selr_countresult;
&               ifdef TRACE
                t01p2int4 (ak_strat, 'countresult ', selrec.selr_countresult
                      ,        'key_cnt_offs', selrec.selr_key_cnt_offs);
&               endif
                s41p4int( m.mb_qual^.mr_keycnt, 2,
                      selrec.selr_key_cnt_offs, _res );
                m.mb_qual^.mr_keycnt[ 1 ] := csp_defined_byte;
                IF  ( selrec.selr_isintersect )
                THEN
                    BEGIN
                    IF  ( m.mb_trns^.trError_gg00 = e_ok )
                    THEN
                        b01move_filecontent( m.mb_trns^,
                              selrec.selr_intersect_id, selrec.selr_resf_id );
                    (*ENDIF*) 
                    _aux_error := m.mb_trns^.trError_gg00;
                    b01destroy_file( m.mb_trns^, selrec.selr_intersect_id );
                    IF  ( _aux_error <> e_ok )
                    THEN
                        m.mb_trns^.trError_gg00 := _aux_error;
                    (*ENDIF*) 
                    END;
                (*ENDIF*) 
                END;
            (*ENDIF*) 
            IF  ( select_vars.sv_trunc_part2 )
            THEN
                m.mb_data_len  := 0;
            (*ENDIF*) 
            IF  (( selrec.selr_countresult = 0)        AND
                ( NOT select_vars.sv_no_oj_destroy_f ) AND
                ( m.mb_type2 <> mm_with_join )         AND
                (* PTS 1113493 E.Z. *)
                ( m.mb_type2 <> mm_first_join_select ) AND
                ( selrec.selr_resf_id.fileTfnTemp_gg00 = ttfnJoinResult_egg00 ) AND
                ( selrec.selr_resf_id.fileTfn_gg00     = tfnTemp_egg00       ) AND
                ( hsDropFile_egg00 in selrec.selr_resf_id.fileHandling_gg00  ))
            THEN
                (* destroy file in case of empty join result *)
                b01destroy_file( m.mb_trns^, selrec.selr_resf_id );
            (*ENDIF*) 
            IF  ( m.mb_trns^.trError_gg00 = e_ok ) AND
                ( m.mb_type <> m_return_result )
            THEN
                BEGIN
                CASE m.mb_type OF
                    m_select :
                        m.mb_type2 := mm_file;
                    m_insert_select :
                        BEGIN
                        IF  m.mb_data^.mbp_info.rb_into_temp
                        THEN
                            BEGIN
                            (* PTS 1119178 E.Z. *)
                            m.mb_data_len := cgg_rec_key_offset +
                                  sizeof (tgg00_Surrogate) + 2;
                            m.mb_type2 := mm_key
                            END
                        ELSE
                            m.mb_type2 := mm_nil;
                        (*ENDIF*) 
                        (* PTS 1118423 E.Z. *)
                        m.mb_qual^.mr_first_serial := selfields.sfp_first_serial;
                        m.mb_qual^.mr_last_serial  := selfields.sfp_last_serial;
                        END;
                    OTHERWISE
                        m.mb_type2 := mm_nil;
                    END;
                (*ENDCASE*) 
                m.mb_type   := m_return_result;
                m.mb_struct := mbs_result;
                END;
            (*ENDIF*) 
            END
        ELSE
            BEGIN
            m.mb_qual_len                       := mxgg_mb_part1head + mxgg_mb_part1_return;
            m.mb_qual^.mr_restree               := selrec.selr_resf_id;
            m.mb_qual^.mr_restree.fileRoot_gg00 := NIL_PAGE_NO_GG00;
            IF  ( selrec.selr_one_result )
            THEN
                IF  ( selrec.selr_countresult = 0 )
                THEN
                    BEGIN
                    IF  ( NOT gg_strategy.str_corr_single )
                    THEN
                        m.mb_trns^.trError_gg00 := e_no_next_record;
                    (*ENDIF*) 
                    m.mb_data_len  := 0
                    END
                ELSE
                    BEGIN
                    g10mv4 ('VKB720',  13,    
                          sizeof(selrec.selr_selectbuffer.lbuf), m.mb_data_size,
                          selrec.selr_selectbuffer.lbuf, 1, m.mb_data^.mbp_4kbuf, 1, selrec.selr_recl,
                          m.mb_trns^.trError_gg00);
                    m.mb_struct    := mbs_result;
                    m.mb_type      := m_return_result;
                    m.mb_type2     := mm_nil;
                    m.mb_data_len  := selrec.selr_recl
                    END
                (*ENDIF*) 
            ELSE
                BEGIN
                IF  ( selrec.selr_countresult > 0 )
                THEN
                    BEGIN
                    selrec.selr_invkey.len := 0;
                    WITH _set_result DO
                        BEGIN
                        bd_key_check_len := 0;
                        bd_max_rec_cnt   := 1;
                        bd_max_fill_len  := mxsp_buf;
                        bd_next          := true;
                        bd_drop_page     := false;
                        END;
                    (*ENDWITH*) 
                    selrec.selr_tree_pos.tpsPno_gg00 := NIL_PAGE_NO_GG00;
                    b07cnext_record( m.mb_trns^, selrec.selr_resf_id,
                          selrec.selr_invkey, _set_result, selrec.selr_tree_pos,
                          m.mb_data^.mbp_buf );
                    IF  ( m.mb_trns^.trError_gg00 = e_key_not_found ) OR
                        ( m.mb_trns^.trError_gg00 = e_ok )
                    THEN
                        BEGIN
                        m.mb_struct       := mbs_result;
                        m.mb_type         := m_return_result;
                        m.mb_type2        := mm_nil;
                        m.mb_data_len     := selrec.selr_recl;
                        selrec.selr_invkey.len := m.mb_data^.mbp_keylen;
                        g10mv1 ('VKB720',  14,    
                              m.mb_data_size, sizeof(selrec.selr_invkey.k),
                              m.mb_data^.mbp_buf, cgg_rec_key_offset+1,
                              selrec.selr_invkey.k, 1, selrec.selr_invkey.len,
                              m.mb_trns^.trError_gg00);
                        IF  ( m.mb_trns^.trError_gg00 <> e_move_error )
                        THEN
                            BEGIN
                            b07cdel_record( m.mb_trns^, selrec.selr_resf_id,
                                  selrec.selr_invkey );
                            m.mb_trns^.trError_gg00 := e_ok;
                            END;
                        (*ENDIF*) 
                        END
                    ELSE
                        m.mb_data_len  := 0
                    (*ENDIF*) 
                    END
                ELSE
                    BEGIN
                    IF  ( NOT gg_strategy.str_corr_single )
                    THEN
                        m.mb_trns^.trError_gg00 := e_no_next_record;
                    (*ENDIF*) 
                    m.mb_struct    := mbs_result;
                    m.mb_type      := m_return_result;
                    m.mb_type2     := mm_nil;
                    m.mb_data_len  := 0;
                    END
                (*ENDIF*) 
                END
            (*ENDIF*) 
            END;
        (*ENDIF*) 
        s41p4int( m.mb_qual^.mr_resnum, 2,
              selrec.selr_countresult, _res );
        m.mb_qual^.mr_resnum[ 1 ] := csp_defined_byte;
        m.mb_qual^.mr_pagecnt     :=
              m.mb_trns^.trRteCommPtr_gg00^.file_record_cnt;
        m.mb_qual^.mr_res_build   := true;
        END
    (*ENDIF*) 
    END;
(*ENDIF*) 
IF  ( select_vars.sv_tree.fileTfnTemp_gg00 = ttfnComplexSelect_egg00 ) AND
    ( select_vars.sv_tree.fileTfn_gg00     = tfnTemp_egg00 )
THEN
    BEGIN
    _aux_error := m.mb_trns^.trError_gg00;
    b01destroy_file( m.mb_trns^, select_vars.sv_tree );
    IF  ( _aux_error <> e_ok )
    THEN
        m.mb_trns^.trError_gg00 := _aux_error
    (*ENDIF*) 
    END;
(*ENDIF*) 
IF  ( select_vars.sv_type =  m_insert_select )
    AND
    (( select_vars.sv_type2 <> mm_distributed ) OR
    ( select_vars.sv_tree.fileResultSite_gg00 <> g01localsite ))
    AND
    ( select_vars.sv_tree.fileTfn_gg00     = tfnTemp_egg00 )
    AND
    ( select_vars.sv_tree.fileTfnTemp_gg00 = ttfnInternResult_egg00 )
THEN
    BEGIN
    _aux_error := m.mb_trns^.trError_gg00;
    b01destroy_file( m.mb_trns^, select_vars.sv_tree );
    IF  ( _aux_error <> e_ok )
    THEN
        m.mb_trns^.trError_gg00 := _aux_error
    (*ENDIF*) 
    END;
(*ENDIF*) 
IF  ( m.mb_trns^.trError_gg00 <> e_ok )
THEN
    BEGIN
    IF  ( m.mb_trns^.trError_gg00 = e_key_not_found )
    THEN
        (* may happen if index-tree and prim-tree *)
        (* are inconsistent, perhaps because of   *)
        (* swapped bits                           *)
        m.mb_trns^.trError_gg00 := e_primkey_not_found;
    (*ENDIF*) 
    _aux_error   := m.mb_trns^.trError_gg00;
    m.mb_qual_len := 0;
    m.mb_data_len := 0;
    IF  ((selrec.selr_resf_id.fileRoot_gg00 <> NIL_PAGE_NO_GG00) AND
        select_vars.sv_file_to_drop)
    THEN
        IF  (
            (
            NOT
            ( gg_strategy.str_strategy in a70glob_fetch_strats )
            AND NOT
            (
            ( m.mb_type  IN [ m_update, m_delete      ] ) AND
            ( m.mb_type2 IN [ mm_qual,  mm_qual_no_opt] )
            )
            AND NOT ( m.mb_type = m_insert_select )
            )
            OR
            ( _aux_error = e_too_many_resultsets )
            )
            AND
            ( selrec.selr_resf_id.fileTfn_gg00 = tfnTemp_egg00 )
        THEN
            IF  (( selrec.selr_resf_id.fileTfnTemp_gg00 <> ttfnInto_egg00 ) AND
                (* PTS 1113493 E.Z. *)
                ( m.mb_type2 <> mm_first_join_select ) AND
                ( m.mb_type2 <> mm_with_join ))
            THEN
                b01destroy_file( m.mb_trns^, selrec.selr_resf_id )
            ELSE
                IF  ( NOT selrec.selr_one_result )
                THEN
                    b01empty_file( m.mb_trns^, selrec.selr_resf_id );
                (*ENDIF*) 
            (*ENDIF*) 
        (*ENDIF*) 
    (*ENDIF*) 
    m.mb_trns^.trError_gg00 := _aux_error
    END;
(*ENDIF*) 
END;
 
(*------------------------------*) 
 
PROCEDURE
      kb720check_upd (
            VAR m           : tgg_mess_block;
            VAR selrec      : tkb7_select_param;
            VAR strat_col   : tsp_int2;
            VAR start       : tsp_int2;
            VAR stop        : tsp_int2);
 
VAR
      _curr_col : tsp_int2;
 
BEGIN
(* *)
_curr_col := start;
WHILE ( NOT selrec.selr_intern_dist ) AND ( _curr_col < stop ) DO
    IF  ( m.mb_st^[ _curr_col ].etype = m.mb_st^[ strat_col ].etype ) AND
        ( m.mb_st^[ _curr_col ].epos  = m.mb_st^[ strat_col ].epos ) AND
        ( m.mb_st^[ _curr_col ].elen_var = m.mb_st^[ strat_col ].elen_var )
    THEN
        selrec.selr_intern_dist := true
    ELSE
        _curr_col := _curr_col + 1
    (*ENDIF*) 
(*ENDWHILE*) 
END;
 
&ifdef trace
(*------------------------------*) 
 
PROCEDURE
      k720trace_selrec (VAR selrec : tkb7_select_param);
 
BEGIN
IF  t01trace (kb)
THEN
    WITH selrec DO
        BEGIN
        t01treeid (kb, 'selr_resf_id', selr_resf_id        );
        t01treeid (kb, 'selr_inv_id ', selr_inv_id         );
        t01treeid (kb, 'selr_distinc', selr_distinct_id    );
        t01treeid (kb, 'selr_interse', selr_intersect_id   );
        t01p2int4 (kb, 'countresult ', selr_countresult
              ,        'maxresult   ', selr_maxresult      );
        t01p2int4 (kb, 'group_count ', selr_group_count
              ,        'union_icnt  ', selr_union_icnt     );
        t01p2int4 (kb, 'cnt_outer_jo', selr_cnt_outer_join
              ,        'r_currpos   ', selr_r_currpos      );
        t01p2int4 (kb, 'r_endpos    ', selr_r_endpos
              ,        'l_currpos   ', selr_l_currpos      );
        t01p2int4 (kb, 'l_endpos    ', selr_l_endpos
              ,        'lmaxpos     ', selr_lmaxpos        );
        t01p2int4 (kb, 'first_jlen  ', selr_first_jlen
              ,        'l_defbyte_po', selr_l_defbyte_pos  );
        t01p2int4 (kb, 'keyl        ', selr_keyl
              ,        'recl        ', selr_recl           );
        t01int4   (kb, 'distinct    ', ord (selr_distinct) );
        t01bool2  (kb, 'distinct_byt', selr_distinct_bytes
              ,        'union       ', selr_union          );
        t01bool2  (kb, 'one_result  ', selr_one_result
              ,        'subquery    ', selr_subquery       );
        t01bool2  (kb, 'intern_dist ', selr_intern_dist
              ,        'is nokey    ', selr_is_nokey       );
        t01bool2  (kb, 'count all   ', selr_count_all
              ,        'count bd    ', selr_count_bd       );
        t01bool2  (kb, 'use rowno   ', selr_use_rowno
              ,        'fulfilled   ', selr_fulfilled      );
        t01bool2  (kb, 'append_all  ', selr_append_all
              ,        'union select', selr_union_select   );
        t01bool2  (kb, 'is union    ', selr_isunion
              ,        'is except   ', selr_isexcept       );
        t01bool2  (kb, 'is intersect', selr_isintersect
              ,        'is all      ', selr_isall          );
        END
    (*ENDWITH*) 
(*ENDIF*) 
END;
 
&endif
 
.CM *-END-* code ----------------------------------------
.SP 2 
***********************************************************
.PA 
