firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-24 20:43:04 +01:00
Code Issues
d38d8dccbd
firebird-mirror/src/dsql/gen.cpp

3149 lines
75 KiB
C++
Raw Blame History

/*
* PROGRAM: Dynamic SQL runtime support
* MODULE: gen.cpp
* DESCRIPTION: Routines to generate BLR.
*
* The contents of this file are subject to the Interbase Public
* License Version 1.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy
* of the License at http://www.Inprise.com/IPL.html
*
* Software distributed under the License is distributed on an
* "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
* or implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code was created by Inprise Corporation
* and its predecessors. Portions created by Inprise Corporation are
* Copyright (C) Inprise Corporation.
*
* All Rights Reserved.
* Contributor(s): ______________________________________
* 2001.6.21 Claudio Valderrama: BREAK and SUBSTRING.
* 2001.07.28 John Bellardo: Added code to generate blr_skip.
* 2002.07.30 Arno Brinkman: Added code, procedures to generate COALESCE, CASE
* 2002.09.28 Dmitry Yemanov: Reworked internal_info stuff, enhanced
* exception handling in SPs/triggers,
* implemented ROWS_AFFECTED system variable
* 2002.10.21 Nickolay Samofatov: Added support for explicit pessimistic locks
* 2002.10.29 Nickolay Samofatov: Added support for savepoints
* 2003.10.05 Dmitry Yemanov: Added support for explicit cursors in PSQL
* 2004.01.16 Vlad Horsun: Added support for default parameters and
* EXECUTE BLOCK statement
* Adriano dos Santos Fernandes
*/
#include "firebird.h"
#include <string.h>
#include <stdio.h>
#include "../dsql/dsql.h"
#include "../dsql/node.h"
#include "../dsql/DdlNodes.h"
#include "../dsql/StmtNodes.h"
#include "../jrd/ibase.h"
#include "../jrd/align.h"
#include "../jrd/constants.h"
#include "../jrd/intl.h"
#include "../jrd/jrd.h"
#include "../jrd/val.h"
#include "../dsql/ddl_proto.h"
#include "../dsql/errd_proto.h"
#include "../dsql/gen_proto.h"
#include "../dsql/make_proto.h"
#include "../dsql/metd_proto.h"
#include "../dsql/misc_func.h"
#include "../dsql/utld_proto.h"
#include "../jrd/thread_proto.h"
#include "../jrd/dsc_proto.h"
#include "../jrd/why_proto.h"
#include "gen/iberror.h"
#include "../common/StatusArg.h"
using namespace Jrd;
using namespace Dsql;
using namespace Firebird;
static void gen_aggregate(CompiledStatement*, const dsql_nod*);
static void gen_cast(CompiledStatement*, const dsql_nod*);
static void gen_coalesce(CompiledStatement*, const dsql_nod*);
static void gen_constant(CompiledStatement*, const dsc*, bool);
static void gen_constant(CompiledStatement*, dsql_nod*, bool);
static void gen_error_condition(CompiledStatement*, const dsql_nod*);
static void gen_exec_stmt(CompiledStatement* statement, const dsql_nod* node);
static void gen_field(CompiledStatement*, const dsql_ctx*, const dsql_fld*, dsql_nod*);
static void gen_for_select(CompiledStatement*, const dsql_nod*);
static void gen_gen_id(CompiledStatement*, const dsql_nod*);
static void gen_join_rse(CompiledStatement*, const dsql_nod*);
static void gen_map(CompiledStatement*, dsql_map*);
static inline void gen_optional_expr(CompiledStatement*, const UCHAR code, dsql_nod*);
static void gen_parameter(CompiledStatement*, const dsql_par*);
static void gen_plan(CompiledStatement*, const dsql_nod*);
static void gen_relation(CompiledStatement*, dsql_ctx*);
static void gen_rse(CompiledStatement*, const dsql_nod*);
static void gen_searched_case(CompiledStatement*, const dsql_nod*);
static void gen_select(CompiledStatement*, dsql_nod*);
static void gen_simple_case(CompiledStatement*, const dsql_nod*);
static void gen_sort(CompiledStatement*, dsql_nod*);
static void gen_statement(CompiledStatement*, const dsql_nod*);
static void gen_sys_function(CompiledStatement*, const dsql_nod*);
static void gen_table_lock(CompiledStatement*, const dsql_nod*, USHORT);
static void gen_udf(CompiledStatement*, const dsql_nod*);
static void gen_union(CompiledStatement*, const dsql_nod*);
static void stuff_context(CompiledStatement*, const dsql_ctx*);
static void stuff_meta_string(CompiledStatement*, const char*);
static void stuff_word(CompiledStatement*, USHORT);
// STUFF is defined in dsql.h for use in common with ddl.c
// The following are passed as the third argument to gen_constant
const bool NEGATE_VALUE = true;
const bool USE_VALUE = false;
void GEN_hidden_variables(CompiledStatement* statement, bool inExpression)
{
/**************************************
*
* G E N _ h i d d e n _ v a r i a b l e s
*
**************************************
*
* Function
* Emit BLR for hidden variables.
*
**************************************/
if (statement->req_hidden_vars.isEmpty())
return;
if (inExpression)
{
stuff(statement, blr_stmt_expr);
if (statement->req_hidden_vars.getCount() > 1)
stuff(statement, blr_begin);
}
for (DsqlNodStack::const_iterator i(statement->req_hidden_vars); i.hasData(); ++i)
{
const dsql_nod* varNode = i.object()->nod_arg[1];
const dsql_var* var = (dsql_var*) varNode->nod_arg[e_var_variable];
statement->append_uchar(blr_dcl_variable);
statement->append_ushort(var->var_variable_number);
GEN_descriptor(statement, &varNode->nod_desc, true);
}
if (inExpression && statement->req_hidden_vars.getCount() > 1)
stuff(statement, blr_end);
// Clear it for GEN_expr not regenerate them.
statement->req_hidden_vars.clear();
}
/**
GEN_expr
@brief Generate blr for an arbitrary expression.
@param statement
@param node
**/
void GEN_expr(CompiledStatement* statement, dsql_nod* node)
{
UCHAR blr_operator;
const dsql_ctx* context;
switch (node->nod_type)
{
case nod_alias:
GEN_expr(statement, node->nod_arg[e_alias_value]);
return;
case nod_aggregate:
gen_aggregate(statement, node);
return;
case nod_constant:
gen_constant(statement, node, USE_VALUE);
return;
case nod_derived_field:
// ASF: If we are not referencing a field, we should evaluate the expression based on
// a set (ORed) of contexts. If any of them are in a valid position the expression is
// evaluated, otherwise a NULL will be returned. This is fix for CORE-1246.
if (node->nod_arg[e_derived_field_value]->nod_type != nod_derived_field &&
node->nod_arg[e_derived_field_value]->nod_type != nod_field &&
node->nod_arg[e_derived_field_value]->nod_type != nod_dbkey &&
node->nod_arg[e_derived_field_value]->nod_type != nod_map)
{
const dsql_ctx* ctx = (dsql_ctx*) node->nod_arg[e_derived_field_context];
if (ctx->ctx_main_derived_contexts.hasData())
{
if (ctx->ctx_main_derived_contexts.getCount() > MAX_UCHAR)
{
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-204) <<
Arg::Gds(isc_imp_exc) <<
Arg::Gds(isc_ctx_too_big));
}
stuff(statement, blr_derived_expr);
stuff(statement, ctx->ctx_main_derived_contexts.getCount());
for (DsqlContextStack::const_iterator stack(ctx->ctx_main_derived_contexts);
stack.hasData(); ++stack)
{
fb_assert(stack.object()->ctx_context <= MAX_UCHAR);
stuff(statement, stack.object()->ctx_context);
}
}
}
GEN_expr(statement, node->nod_arg[e_derived_field_value]);
return;
case nod_extract:
stuff(statement, blr_extract);
stuff(statement, node->nod_arg[e_extract_part]->getSlong());
GEN_expr(statement, node->nod_arg[e_extract_value]);
return;
case nod_strlen:
stuff(statement, blr_strlen);
stuff(statement, node->nod_arg[e_strlen_type]->getSlong());
GEN_expr(statement, node->nod_arg[e_strlen_value]);
return;
case nod_dbkey:
node = node->nod_arg[0];
context = (dsql_ctx*) node->nod_arg[e_rel_context];
stuff(statement, blr_dbkey);
stuff_context(statement, context);
return;
case nod_rec_version:
node = node->nod_arg[0];
context = (dsql_ctx*) node->nod_arg[e_rel_context];
stuff(statement, blr_record_version);
stuff_context(statement, context);
return;
case nod_dom_value:
stuff(statement, blr_fid);
stuff(statement, 0); // Context
stuff_word(statement, 0); // Field id
return;
case nod_field:
gen_field(statement,
(dsql_ctx*) node->nod_arg[e_fld_context],
(dsql_fld*) node->nod_arg[e_fld_field],
node->nod_arg[e_fld_indices]);
return;
case nod_user_name:
stuff(statement, blr_user_name);
return;
case nod_current_time:
if (node->nod_arg[0])
{
const dsql_nod* const_node = node->nod_arg[0];
fb_assert(const_node->nod_type == nod_constant);
const int precision = (int) const_node->getSlong();
stuff(statement, blr_current_time2);
stuff(statement, precision);
}
else {
stuff(statement, blr_current_time);
}
return;
case nod_current_timestamp:
if (node->nod_arg[0])
{
const dsql_nod* const_node = node->nod_arg[0];
fb_assert(const_node->nod_type == nod_constant);
const int precision = (int) const_node->getSlong();
stuff(statement, blr_current_timestamp2);
stuff(statement, precision);
}
else {
stuff(statement, blr_current_timestamp);
}
return;
case nod_current_date:
stuff(statement, blr_current_date);
return;
case nod_current_role:
stuff(statement, blr_current_role);
return;
case nod_udf:
gen_udf(statement, node);
return;
case nod_sys_function:
gen_sys_function(statement, node);
return;
case nod_variable:
{
const dsql_var* variable = (dsql_var*) node->nod_arg[e_var_variable];
if (variable->var_type == VAR_input)
{
stuff(statement, blr_parameter2);
stuff(statement, variable->var_msg_number);
stuff_word(statement, variable->var_msg_item);
stuff_word(statement, variable->var_msg_item + 1);
}
else
{
stuff(statement, blr_variable);
stuff_word(statement, variable->var_variable_number);
}
}
return;
case nod_join:
gen_join_rse(statement, node);
return;
case nod_map:
{
const dsql_map* map = (dsql_map*) node->nod_arg[e_map_map];
context = (dsql_ctx*) node->nod_arg[e_map_context];
stuff(statement, blr_fid);
stuff_context(statement, context);
stuff_word(statement, map->map_position);
}
return;
case nod_parameter:
gen_parameter(statement, (dsql_par*) node->nod_arg[e_par_parameter]);
return;
case nod_relation:
gen_relation(statement, (dsql_ctx*) node->nod_arg[e_rel_context]);
return;
case nod_rse:
gen_rse(statement, node);
return;
case nod_derived_table:
gen_rse(statement, node->nod_arg[e_derived_table_rse]);
return;
case nod_exists:
stuff(statement, blr_any);
gen_rse(statement, node->nod_arg[0]);
return;
case nod_singular:
stuff(statement, blr_unique);
gen_rse(statement, node->nod_arg[0]);
return;
case nod_agg_count:
if (node->nod_count)
blr_operator = (node->nod_flags & NOD_AGG_DISTINCT) ?
blr_agg_count_distinct : blr_agg_count2;
else
blr_operator = blr_agg_count;
break;
case nod_agg_min:
blr_operator = blr_agg_min;
break;
case nod_agg_max:
blr_operator = blr_agg_max;
break;
case nod_window:
GEN_expr(statement, node->nod_arg[0]);
return;
case nod_agg_average:
blr_operator = (node->nod_flags & NOD_AGG_DISTINCT) ?
blr_agg_average_distinct : blr_agg_average;
break;
case nod_agg_total:
blr_operator = (node->nod_flags & NOD_AGG_DISTINCT) ? blr_agg_total_distinct : blr_agg_total;
break;
case nod_agg_average2:
blr_operator = (node->nod_flags & NOD_AGG_DISTINCT) ?
blr_agg_average_distinct : blr_agg_average;
break;
case nod_agg_total2:
blr_operator = (node->nod_flags & NOD_AGG_DISTINCT) ? blr_agg_total_distinct : blr_agg_total;
break;
case nod_agg_list:
blr_operator = (node->nod_flags & NOD_AGG_DISTINCT) ? blr_agg_list_distinct : blr_agg_list;
break;
case nod_and:
blr_operator = blr_and;
break;
case nod_or:
blr_operator = blr_or;
break;
case nod_not:
blr_operator = blr_not;
break;
case nod_eql_all:
case nod_eql_any:
case nod_eql:
blr_operator = blr_eql;
break;
case nod_equiv:
blr_operator = blr_equiv;
break;
case nod_neq_all:
case nod_neq_any:
case nod_neq:
blr_operator = blr_neq;
break;
case nod_gtr_all:
case nod_gtr_any:
case nod_gtr:
blr_operator = blr_gtr;
break;
case nod_leq_all:
case nod_leq_any:
case nod_leq:
blr_operator = blr_leq;
break;
case nod_geq_all:
case nod_geq_any:
case nod_geq:
blr_operator = blr_geq;
break;
case nod_lss_all:
case nod_lss_any:
case nod_lss:
blr_operator = blr_lss;
break;
case nod_between:
blr_operator = blr_between;
break;
case nod_containing:
blr_operator = blr_containing;
break;
case nod_similar:
stuff(statement, blr_similar);
GEN_expr(statement, node->nod_arg[e_similar_value]);
GEN_expr(statement, node->nod_arg[e_similar_pattern]);
if (node->nod_arg[e_similar_escape])
{
stuff(statement, 1);
GEN_expr(statement, node->nod_arg[e_similar_escape]);
}
else
stuff(statement, 0);
return;
case nod_starting:
blr_operator = blr_starting;
break;
case nod_missing:
blr_operator = blr_missing;
break;
case nod_like:
blr_operator = (node->nod_count == 2) ? blr_like : blr_ansi_like;
break;
case nod_add:
blr_operator = blr_add;
break;
case nod_subtract:
blr_operator = blr_subtract;
break;
case nod_multiply:
blr_operator = blr_multiply;
break;
case nod_negate:
{
dsql_nod* child = node->nod_arg[0];
if (child->nod_type == nod_constant && DTYPE_IS_NUMERIC(child->nod_desc.dsc_dtype))
{
gen_constant(statement, child, NEGATE_VALUE);
return;
}
}
blr_operator = blr_negate;
break;
case nod_divide:
blr_operator = blr_divide;
break;
case nod_add2:
blr_operator = blr_add;
break;
case nod_subtract2:
blr_operator = blr_subtract;
break;
case nod_multiply2:
blr_operator = blr_multiply;
break;
case nod_divide2:
blr_operator = blr_divide;
break;
case nod_concatenate:
blr_operator = blr_concatenate;
break;
case nod_null:
blr_operator = blr_null;
break;
case nod_any:
blr_operator = blr_any;
break;
case nod_ansi_any:
blr_operator = blr_ansi_any;
break;
case nod_ansi_all:
blr_operator = blr_ansi_all;
break;
case nod_via:
blr_operator = blr_via;
break;
case nod_internal_info:
blr_operator = blr_internal_info;
break;
case nod_upcase:
blr_operator = blr_upcase;
break;
case nod_lowcase:
blr_operator = blr_lowcase;
break;
case nod_substr:
blr_operator = blr_substring;
break;
case nod_cast:
gen_cast(statement, node);
return;
case nod_gen_id:
case nod_gen_id2:
gen_gen_id(statement, node);
return;
case nod_coalesce:
gen_coalesce(statement, node);
return;
case nod_simple_case:
gen_simple_case(statement, node);
return;
case nod_searched_case:
gen_searched_case(statement, node);
return;
case nod_trim:
stuff(statement, blr_trim);
stuff(statement, node->nod_arg[e_trim_specification]->getSlong());
if (node->nod_arg[e_trim_characters])
{
stuff(statement, blr_trim_characters);
GEN_expr(statement, node->nod_arg[e_trim_characters]);
}
else
stuff(statement, blr_trim_spaces);
GEN_expr(statement, node->nod_arg[e_trim_value]);
return;
case nod_assign:
stuff(statement, blr_assignment);
GEN_expr(statement, node->nod_arg[0]);
GEN_expr(statement, node->nod_arg[1]);
return;
case nod_hidden_var:
stuff(statement, blr_stmt_expr);
// If it was not pre-declared, declare it now.
if (statement->req_hidden_vars.hasData())
{
const dsql_var* var = (dsql_var*) node->nod_arg[e_hidden_var_var]->nod_arg[e_var_variable];
stuff(statement, blr_begin);
statement->append_uchar(blr_dcl_variable);
statement->append_ushort(var->var_variable_number);
GEN_descriptor(statement, &node->nod_arg[e_hidden_var_var]->nod_desc, true);
}
stuff(statement, blr_assignment);
GEN_expr(statement, node->nod_arg[e_hidden_var_expr]);
GEN_expr(statement, node->nod_arg[e_hidden_var_var]);
if (statement->req_hidden_vars.hasData())
stuff(statement, blr_end);
GEN_expr(statement, node->nod_arg[e_hidden_var_var]);
return;
default:
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-901) <<
Arg::Gds(isc_dsql_internal_err) <<
// expression evaluation not supported
Arg::Gds(isc_expression_eval_err) <<
Arg::Gds(isc_dsql_eval_unknode) << Arg::Num(node->nod_type));
}
stuff(statement, blr_operator);
dsql_nod* const* ptr = node->nod_arg;
for (const dsql_nod* const* const end = ptr + node->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
// Check whether the node we just processed is for a dialect 3
// operation which gives a different result than the corresponding
// operation in dialect 1. If it is, and if the client dialect is 2,
// issue a warning about the difference.
switch (node->nod_type)
{
case nod_add2:
case nod_subtract2:
case nod_multiply2:
case nod_divide2:
case nod_agg_total2:
case nod_agg_average2:
dsc desc;
MAKE_desc(statement, &desc, node, NULL);
if ((node->nod_flags & NOD_COMP_DIALECT) &&
(statement->req_client_dialect == SQL_DIALECT_V6_TRANSITION))
{
const char* s = 0;
char message_buf[8];
switch (node->nod_type)
{
case nod_add2:
s = "add";
break;
case nod_subtract2:
s = "subtract";
break;
case nod_multiply2:
s = "multiply";
break;
case nod_divide2:
s = "divide";
break;
case nod_agg_total2:
s = "sum";
break;
case nod_agg_average2:
s = "avg";
break;
default:
sprintf(message_buf, "blr %d", (int) blr_operator);
s = message_buf;
}
ERRD_post_warning(Arg::Warning(isc_dsql_dialect_warning_expr) << Arg::Str(s));
}
}
}
/**
GEN_port
@brief Generate a port from a message. Feel free to rearrange the
order of parameters.
@param statement
@param message
**/
void GEN_port(CompiledStatement* statement, dsql_msg* message)
{
thread_db* tdbb = JRD_get_thread_data();
// if (statement->req_blr_string) {
stuff(statement, blr_message);
stuff(statement, message->msg_number);
stuff_word(statement, message->msg_parameter);
// }
dsql_par* parameter;
ULONG offset = 0;
USHORT number = 0;
for (parameter = message->msg_parameters; parameter; parameter = parameter->par_next)
{
parameter->par_parameter = number++;
const USHORT fromCharSet = parameter->par_desc.getCharSet();
const USHORT toCharSet = (fromCharSet == CS_NONE || fromCharSet == CS_BINARY) ?
fromCharSet : tdbb->getCharSet();
if (parameter->par_desc.dsc_dtype <= dtype_any_text &&
tdbb->getCharSet() != CS_NONE && tdbb->getCharSet() != CS_BINARY)
{
USHORT adjust = 0;
if (parameter->par_desc.dsc_dtype == dtype_varying)
adjust = sizeof(USHORT);
else if (parameter->par_desc.dsc_dtype == dtype_cstring)
adjust = 1;
parameter->par_desc.dsc_length -= adjust;
const USHORT fromCharSetBPC = METD_get_charset_bpc(statement, fromCharSet);
const USHORT toCharSetBPC = METD_get_charset_bpc(statement, toCharSet);
INTL_ASSIGN_TTYPE(&parameter->par_desc, INTL_CS_COLL_TO_TTYPE(toCharSet,
(fromCharSet == toCharSet ? INTL_GET_COLLATE(&parameter->par_desc) : 0)));
parameter->par_desc.dsc_length =
UTLD_char_length_to_byte_length(parameter->par_desc.dsc_length / fromCharSetBPC, toCharSetBPC);
parameter->par_desc.dsc_length += adjust;
}
else if (parameter->par_desc.dsc_dtype == dtype_blob &&
parameter->par_desc.dsc_sub_type == isc_blob_text &&
tdbb->getCharSet() != CS_NONE && tdbb->getCharSet() != CS_BINARY)
{
if (fromCharSet != toCharSet)
parameter->par_desc.setTextType(toCharSet);
}
// For older clients - generate an error should they try and
// access data types which did not exist in the older dialect
if (statement->req_client_dialect <= SQL_DIALECT_V5)
switch (parameter->par_desc.dsc_dtype)
{
// In V6.0 - older clients, which we distinguish by
// their use of SQL DIALECT 0 or 1, are forbidden
// from selecting values of new datatypes
case dtype_sql_date:
case dtype_sql_time:
case dtype_int64:
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_dsql_datatype_err) <<
Arg::Gds(isc_sql_dialect_datatype_unsupport) <<
Arg::Num(statement->req_client_dialect) <<
Arg::Str(DSC_dtype_tostring(parameter->par_desc.dsc_dtype)));
break;
default:
// No special action for other data types
break;
}
const USHORT align = type_alignments[parameter->par_desc.dsc_dtype];
if (align)
offset = FB_ALIGN(offset, align);
parameter->par_desc.dsc_address = (UCHAR*)(IPTR) offset;
offset += parameter->par_desc.dsc_length;
// if (statement->req_blr_string)
GEN_descriptor(statement, &parameter->par_desc, false);
}
if (offset > MAX_FORMAT_SIZE)
{
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-204) <<
Arg::Gds(isc_imp_exc) <<
Arg::Gds(isc_blktoobig));
}
message->msg_length = (USHORT) offset;
// Allocate buffer for message
const ULONG new_len = message->msg_length + FB_DOUBLE_ALIGN - 1;
dsql_str* buffer = FB_NEW_RPT(*tdbb->getDefaultPool(), new_len) dsql_str;
message->msg_buffer = (UCHAR*) FB_ALIGN((U_IPTR) buffer->str_data, FB_DOUBLE_ALIGN);
// Relocate parameter descriptors to point direction into message buffer
for (parameter = message->msg_parameters; parameter; parameter = parameter->par_next)
{
parameter->par_desc.dsc_address = message->msg_buffer + (IPTR) parameter->par_desc.dsc_address;
}
}
/**
GEN_request
@brief Generate complete blr for a statement.
@param statement
@param node
**/
void GEN_request( CompiledStatement* statement, dsql_nod* node)
{
if (statement->req_type == REQ_CREATE_DB || statement->req_type == REQ_DDL)
{
DDL_generate(statement, node);
return;
}
if (statement->req_flags & REQ_blr_version4)
stuff(statement, blr_version4);
else
stuff(statement, blr_version5);
if (statement->req_type == REQ_SAVEPOINT)
{
// Do not generate BEGIN..END block around savepoint statement
// to avoid breaking of savepoint logic
statement->req_send = NULL;
statement->req_receive = NULL;
GEN_statement(statement, node);
}
else
{
stuff(statement, blr_begin);
GEN_hidden_variables(statement, false);
switch (statement->req_type)
{
case REQ_SELECT:
case REQ_SELECT_UPD:
case REQ_EMBED_SELECT:
gen_select(statement, node);
break;
case REQ_EXEC_BLOCK:
case REQ_SELECT_BLOCK:
GEN_statement(statement, node);
break;
default:
{
dsql_msg* message = statement->req_send;
if (!message->msg_parameter)
statement->req_send = NULL;
else
{
GEN_port(statement, message);
stuff(statement, blr_receive);
stuff(statement, message->msg_number);
}
message = statement->req_receive;
if (!message->msg_parameter)
statement->req_receive = NULL;
else
GEN_port(statement, message);
GEN_statement(statement, node);
}
}
stuff(statement, blr_end);
}
stuff(statement, blr_eoc);
}
/**
GEN_start_transaction
@brief Generate tpb for set transaction. Use blr string of statement.
If a value is not specified, default is not STUFF'ed, let the
engine handle it.
Do not allow an option to be specified more than once.
@param statement
@param tran_node
**/
void GEN_start_transaction( CompiledStatement* statement, const dsql_nod* tran_node)
{
SSHORT count = tran_node->nod_count;
if (!count)
return;
const dsql_nod* node = tran_node->nod_arg[0];
if (!node)
return;
// Find out isolation level - if specified. This is required for
// specifying the correct lock level in reserving clause.
USHORT lock_level = isc_tpb_shared;
if (count = node->nod_count)
{
while (count--)
{
const dsql_nod* ptr = node->nod_arg[count];
if (!ptr || ptr->nod_type != nod_isolation)
continue;
lock_level = (ptr->nod_flags & NOD_CONSISTENCY) ? isc_tpb_protected : isc_tpb_shared;
}
}
bool sw_access = false, sw_wait = false, sw_isolation = false,
sw_reserve = false, sw_lock_timeout = false;
int misc_flags = 0;
// Stuff some version info.
if (count = node->nod_count)
stuff(statement, isc_tpb_version1);
while (count--)
{
const dsql_nod* ptr = node->nod_arg[count];
if (!ptr)
continue;
switch (ptr->nod_type)
{
case nod_access:
if (sw_access)
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_dsql_dup_option));
sw_access = true;
if (ptr->nod_flags & NOD_READ_ONLY)
stuff(statement, isc_tpb_read);
else
stuff(statement, isc_tpb_write);
break;
case nod_wait:
if (sw_wait)
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_dsql_dup_option));
sw_wait = true;
if (ptr->nod_flags & NOD_NO_WAIT)
stuff(statement, isc_tpb_nowait);
else
stuff(statement, isc_tpb_wait);
break;
case nod_isolation:
if (sw_isolation)
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_dsql_dup_option));
sw_isolation = true;
if (ptr->nod_flags & NOD_CONCURRENCY)
stuff(statement, isc_tpb_concurrency);
else if (ptr->nod_flags & NOD_CONSISTENCY)
stuff(statement, isc_tpb_consistency);
else
{
stuff(statement, isc_tpb_read_committed);
if (ptr->nod_count && ptr->nod_arg[0] && ptr->nod_arg[0]->nod_type == nod_version)
{
if (ptr->nod_arg[0]->nod_flags & NOD_VERSION)
stuff(statement, isc_tpb_rec_version);
else
stuff(statement, isc_tpb_no_rec_version);
}
else
stuff(statement, isc_tpb_no_rec_version);
}
break;
case nod_reserve:
{
if (sw_reserve)
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_dsql_dup_option));
sw_reserve = true;
const dsql_nod* reserve = ptr->nod_arg[0];
if (reserve)
{
const dsql_nod* const* temp = reserve->nod_arg;
for (const dsql_nod* const* end = temp + reserve->nod_count; temp < end; temp++)
{
gen_table_lock(statement, *temp, lock_level);
}
}
}
break;
case nod_tra_misc:
if (misc_flags & ptr->nod_flags)
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_dsql_dup_option));
misc_flags |= ptr->nod_flags;
if (ptr->nod_flags & NOD_NO_AUTO_UNDO)
stuff(statement, isc_tpb_no_auto_undo);
else if (ptr->nod_flags & NOD_IGNORE_LIMBO)
stuff(statement, isc_tpb_ignore_limbo);
else if (ptr->nod_flags & NOD_RESTART_REQUESTS)
stuff(statement, isc_tpb_restart_requests);
break;
case nod_lock_timeout:
if (sw_lock_timeout)
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_dsql_dup_option));
sw_lock_timeout = true;
if (ptr->nod_count == 1 && ptr->nod_arg[0]->nod_type == nod_constant)
{
const int lck_timeout = (int) ptr->nod_arg[0]->getSlong();
stuff(statement, isc_tpb_lock_timeout);
stuff(statement, 2);
stuff_word(statement, lck_timeout);
}
break;
default:
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_dsql_tran_err));
}
}
}
/**
GEN_statement
@brief Generate blr for an arbitrary expression.
@param statement
@param node
**/
void GEN_statement( CompiledStatement* statement, dsql_nod* node)
{
dsql_nod* temp;
dsql_nod** ptr;
const dsql_nod* const* end;
dsql_str* string;
switch (node->nod_type)
{
case nod_assign:
stuff(statement, blr_assignment);
GEN_expr(statement, node->nod_arg[0]);
GEN_expr(statement, node->nod_arg[1]);
return;
case nod_block:
stuff(statement, blr_block);
GEN_statement(statement, node->nod_arg[e_blk_action]);
if (node->nod_count > 1)
{
temp = node->nod_arg[e_blk_errs];
for (ptr = temp->nod_arg, end = ptr + temp->nod_count; ptr < end; ptr++)
{
GEN_statement(statement, *ptr);
}
}
stuff(statement, blr_end);
return;
case nod_class_node:
{
StmtNode* stmtNode = reinterpret_cast<StmtNode*>(node->nod_arg[0]);
stmtNode->genBlr();
return;
}
case nod_for_select:
gen_for_select(statement, node);
return;
case nod_set_generator:
case nod_set_generator2:
stuff(statement, blr_set_generator);
string = (dsql_str*) node->nod_arg[e_gen_id_name];
stuff_cstring(statement, string->str_data);
GEN_expr(statement, node->nod_arg[e_gen_id_value]);
return;
case nod_list:
if (!(node->nod_flags & NOD_SIMPLE_LIST))
stuff(statement, blr_begin);
for (ptr = node->nod_arg, end = ptr + node->nod_count; ptr < end; ptr++)
{
GEN_statement(statement, *ptr);
}
if (!(node->nod_flags & NOD_SIMPLE_LIST))
stuff(statement, blr_end);
return;
case nod_erase:
case nod_erase_current:
case nod_modify:
case nod_modify_current:
case nod_store:
case nod_exec_procedure:
gen_statement(statement, node);
return;
case nod_on_error:
stuff(statement, blr_error_handler);
temp = node->nod_arg[e_err_errs];
stuff_word(statement, temp->nod_count);
for (ptr = temp->nod_arg, end = ptr + temp->nod_count; ptr < end; ptr++)
{
gen_error_condition(statement, *ptr);
}
GEN_statement(statement, node->nod_arg[e_err_action]);
return;
case nod_exec_sql:
stuff(statement, blr_exec_sql);
GEN_expr(statement, node->nod_arg[e_exec_sql_stmnt]);
return;
case nod_exec_into:
if (node->nod_arg[e_exec_into_block])
{
stuff(statement, blr_label);
stuff(statement, (int) (IPTR) node->nod_arg[e_exec_into_label]->nod_arg[e_label_number]);
}
stuff(statement, blr_exec_into);
temp = node->nod_arg[e_exec_into_list];
stuff_word(statement, temp->nod_count);
GEN_expr(statement, node->nod_arg[e_exec_into_stmnt]);
if (node->nod_arg[e_exec_into_block])
{
stuff(statement, 0); // Non-singleton
GEN_statement(statement, node->nod_arg[e_exec_into_block]);
}
else
stuff(statement, 1); // Singleton
for (ptr = temp->nod_arg, end = ptr + temp->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
return;
case nod_exec_stmt:
gen_exec_stmt(statement, node);
return;
case nod_breakleave:
stuff(statement, blr_leave);
stuff(statement, (int)(IPTR) node->nod_arg[e_breakleave_label]->nod_arg[e_label_number]);
return;
case nod_continue:
stuff(statement, blr_continue_loop);
stuff(statement, (int)(IPTR) node->nod_arg[e_continue_label]->nod_arg[e_label_number]);
return;
case nod_abort:
stuff(statement, blr_leave);
stuff(statement, (int) (IPTR) node->nod_arg[e_abrt_number]);
return;
case nod_start_savepoint:
stuff(statement, blr_start_savepoint);
return;
case nod_end_savepoint:
stuff(statement, blr_end_savepoint);
return;
case nod_exception_stmt:
stuff(statement, blr_abort);
string = (dsql_str*) node->nod_arg[e_xcps_name];
temp = node->nod_arg[e_xcps_msg];
// if exception name is undefined,
// it means we have re-initiate semantics here,
// so blr_raise verb should be generated
if (!string)
{
stuff(statement, blr_raise);
return;
}
// if exception value is defined,
// it means we have user-defined exception message here,
// so blr_exception_msg verb should be generated
if (temp)
{
stuff(statement, blr_exception_msg);
}
// otherwise go usual way,
// i.e. generate blr_exception
else
{
stuff(statement, blr_exception);
}
if (string->type != dsql_str::TYPE_DELIMITED)
{
ULONG id_length = string->str_length;
for (TEXT* p = string->str_data; *p && id_length; ++p, --id_length)
{
*p = UPPER(*p);
}
}
stuff_cstring(statement, string->str_data);
// if exception value is defined,
// generate appropriate BLR verbs
if (temp)
{
GEN_expr(statement, temp);
}
return;
case nod_while:
stuff(statement, blr_label);
stuff(statement, (int) (IPTR) node->nod_arg[e_while_label]->nod_arg[e_label_number]);
stuff(statement, blr_loop);
stuff(statement, blr_begin);
stuff(statement, blr_if);
GEN_expr(statement, node->nod_arg[e_while_cond]);
GEN_statement(statement, node->nod_arg[e_while_action]);
stuff(statement, blr_leave);
stuff(statement, (int) (IPTR) node->nod_arg[e_while_label]->nod_arg[e_label_number]);
stuff(statement, blr_end);
return;
case nod_sqlcode:
case nod_gdscode:
stuff(statement, blr_abort);
gen_error_condition(statement, node);
return;
case nod_cursor:
stuff(statement, blr_dcl_cursor);
stuff_word(statement, (int) (IPTR) node->nod_arg[e_cur_number]);
if (node->nod_arg[e_cur_scroll])
{
stuff(statement, blr_scrollable);
}
gen_rse(statement, node->nod_arg[e_cur_rse]);
temp = node->nod_arg[e_cur_rse]->nod_arg[e_rse_items];
stuff_word(statement, temp->nod_count);
ptr = temp->nod_arg;
end = ptr + temp->nod_count;
while (ptr < end) {
GEN_expr(statement, *ptr++);
}
return;
case nod_cursor_open:
case nod_cursor_close:
case nod_cursor_fetch:
{
const dsql_nod* scroll = node->nod_arg[e_cur_stmt_scroll];
// op-code
stuff(statement, blr_cursor_stmt);
if (node->nod_type == nod_cursor_open)
stuff(statement, blr_cursor_open);
else if (node->nod_type == nod_cursor_close)
stuff(statement, blr_cursor_close);
else if (scroll)
stuff(statement, blr_cursor_fetch_scroll);
else
stuff(statement, blr_cursor_fetch);
// cursor reference
dsql_nod* cursor = node->nod_arg[e_cur_stmt_id];
stuff_word(statement, (int) (IPTR) cursor->nod_arg[e_cur_number]);
// scrolling
if (scroll)
{
GEN_expr(statement, scroll->nod_arg[0]);
if (scroll->nod_arg[1])
{
GEN_expr(statement, scroll->nod_arg[1]);
}
else
{
stuff(statement, blr_null);
}
}
// assignment
dsql_nod* list_into = node->nod_arg[e_cur_stmt_into];
if (list_into)
{
dsql_nod* list = cursor->nod_arg[e_cur_rse]->nod_arg[e_rse_items];
if (list->nod_count != list_into->nod_count)
{
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-313) <<
Arg::Gds(isc_dsql_count_mismatch));
}
stuff(statement, blr_begin);
ptr = list->nod_arg;
end = ptr + list->nod_count;
dsql_nod** ptr_to = list_into->nod_arg;
while (ptr < end)
{
stuff(statement, blr_assignment);
GEN_expr(statement, *ptr++);
GEN_expr(statement, *ptr_to++);
}
stuff(statement, blr_end);
}
}
return;
case nod_src_info:
statement->put_debug_src_info(node->nod_line, node->nod_column);
GEN_statement(statement, node->nod_arg[e_src_info_stmt]);
return;
default:
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-901) <<
Arg::Gds(isc_dsql_internal_err) <<
// gen.c: node not supported
Arg::Gds(isc_node_err));
}
}
/**
gen_aggregate
@brief Generate blr for a relation reference.
@param
@param
**/
static void gen_aggregate( CompiledStatement* statement, const dsql_nod* node)
{
dsql_ctx* context = (dsql_ctx*) node->nod_arg[e_agg_context];
bool window = (node->nod_flags & NOD_AGG_WINDOW);
stuff(statement, (window ? blr_window : blr_aggregate));
stuff_context(statement, context);
gen_rse(statement, node->nod_arg[e_agg_rse]);
// Handle PARTITION BY and GROUP BY clause
if (window)
{
stuff(statement, blr_partition_by);
stuff(statement, 0); // partition by expression count
}
else
{
stuff(statement, blr_group_by);
dsql_nod* list = node->nod_arg[e_agg_group];
if (list != NULL)
{
stuff(statement, list->nod_count);
dsql_nod** ptr = list->nod_arg;
for (const dsql_nod* const* end = ptr + list->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
}
else
stuff(statement, 0);
}
// Generate value map
gen_map(statement, context->ctx_map);
}
/**
gen_cast
@brief Generate BLR for a data-type cast operation
@param statement
@param node
**/
static void gen_cast( CompiledStatement* statement, const dsql_nod* node)
{
stuff(statement, blr_cast);
const dsql_fld* field = (dsql_fld*) node->nod_arg[e_cast_target];
DDL_put_field_dtype(statement, field, true);
GEN_expr(statement, node->nod_arg[e_cast_source]);
}
/**
gen_coalesce
@brief Generate BLR for coalesce function
Generate the blr values, begin with a cast and then :
blr_value_if
blr_missing
blr for expression 1
blr_value_if
blr_missing
blr for expression n-1
expression n
blr for expression n-1
@param statement
@param node
**/
static void gen_coalesce( CompiledStatement* statement, const dsql_nod* node)
{
// blr_value_if is used for building the coalesce function
dsql_nod* list = node->nod_arg[0];
stuff(statement, blr_cast);
GEN_descriptor(statement, &node->nod_desc, true);
dsql_nod* const* ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + (list->nod_count - 1); ptr < end; ptr++)
{
// IF (expression IS NULL) THEN
stuff(statement, blr_value_if);
stuff(statement, blr_missing);
GEN_expr(statement, *ptr);
}
// Return values
GEN_expr(statement, *ptr);
list = node->nod_arg[1];
const dsql_nod* const* const begin = list->nod_arg;
ptr = list->nod_arg + list->nod_count;
// if all expressions are NULL return NULL
for (ptr--; ptr >= begin; ptr--)
{
GEN_expr(statement, *ptr);
}
}
/**
gen_constant
@brief Generate BLR for a constant.
@param statement
@param desc
@param negate_value
**/
static void gen_constant( CompiledStatement* statement, const dsc* desc, bool negate_value)
{
SLONG value;
SINT64 i64value;
stuff(statement, blr_literal);
const UCHAR* p = desc->dsc_address;
switch (desc->dsc_dtype)
{
case dtype_short:
GEN_descriptor(statement, desc, true);
value = *(SSHORT *) p;
if (negate_value)
value = -value;
stuff_word(statement, value);
break;
case dtype_long:
GEN_descriptor(statement, desc, true);
value = *(SLONG *) p;
if (negate_value)
value = -value;
//printf("gen.cpp = %p %d\n", *((void**)p), value);
stuff_word(statement, value);
stuff_word(statement, value >> 16);
break;
case dtype_sql_time:
case dtype_sql_date:
GEN_descriptor(statement, desc, true);
value = *(SLONG *) p;
stuff_word(statement, value);
stuff_word(statement, value >> 16);
break;
case dtype_double:
{
// this is used for approximate/large numeric literal
// which is transmitted to the engine as a string.
GEN_descriptor(statement, desc, true);
// Length of string literal, cast because it could be > 127 bytes.
const USHORT l = (USHORT)(UCHAR) desc->dsc_scale;
if (negate_value)
{
stuff_word(statement, l + 1);
stuff(statement, '-');
}
else {
stuff_word(statement, l);
}
if (l)
statement->append_raw_string(p, l);
}
break;
case dtype_int64:
i64value = *(SINT64 *) p;
if (negate_value)
i64value = -i64value;
else if (i64value == MIN_SINT64)
{
// UH OH!
// yylex correctly recognized the digits as the most-negative
// possible INT64 value, but unfortunately, there was no
// preceding '-' (a fact which the lexer could not know).
// The value is too big for a positive INT64 value, and it
// didn't contain an exponent so it's not a valid DOUBLE
// PRECISION literal either, so we have to bounce it.
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
Arg::Gds(isc_arith_except) <<
Arg::Gds(isc_numeric_out_of_range));
}
// We and the lexer both agree that this is an SINT64 constant,
// and if the value needed to be negated, it already has been.
// If the value will fit into a 32-bit signed integer, generate
// it that way, else as an INT64.
if ((i64value >= (SINT64) MIN_SLONG) && (i64value <= (SINT64) MAX_SLONG))
{
stuff(statement, blr_long);
stuff(statement, desc->dsc_scale);
stuff_word(statement, i64value);
stuff_word(statement, i64value >> 16);
}
else
{
stuff(statement, blr_int64);
stuff(statement, desc->dsc_scale);
stuff_word(statement, i64value);
stuff_word(statement, i64value >> 16);
stuff_word(statement, i64value >> 32);
stuff_word(statement, i64value >> 48);
}
break;
case dtype_quad:
case dtype_blob:
case dtype_array:
case dtype_timestamp:
GEN_descriptor(statement, desc, true);
value = *(SLONG *) p;
stuff_word(statement, value);
stuff_word(statement, value >> 16);
value = *(SLONG *) (p + 4);
stuff_word(statement, value);
stuff_word(statement, value >> 16);
break;
case dtype_text:
{
const USHORT length = desc->dsc_length;
GEN_descriptor(statement, desc, true);
if (length)
statement->append_raw_string(p, length);
}
break;
default:
// gen_constant: datatype not understood
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-103) <<
Arg::Gds(isc_dsql_constant_err));
}
}
/**
gen_constant
@brief Generate BLR for a constant.
@param statement
@param node
@param negate_value
**/
static void gen_constant( CompiledStatement* statement, dsql_nod* node, bool negate_value)
{
if (node->nod_desc.dsc_dtype == dtype_text)
node->nod_desc.dsc_length = ((dsql_str*) node->nod_arg[0])->str_length;
gen_constant(statement, &node->nod_desc, negate_value);
}
/**
GEN_descriptor
@brief Generate a blr descriptor from an internal descriptor.
@param statement
@param desc
@param texttype
**/
void GEN_descriptor( CompiledStatement* statement, const dsc* desc, bool texttype)
{
switch (desc->dsc_dtype)
{
case dtype_text:
if (texttype || desc->dsc_ttype() == ttype_binary || desc->dsc_ttype() == ttype_none)
{
stuff(statement, blr_text2);
stuff_word(statement, desc->dsc_ttype());
}
else
{
stuff(statement, blr_text2); // automatic transliteration
stuff_word(statement, ttype_dynamic);
}
stuff_word(statement, desc->dsc_length);
break;
case dtype_varying:
if (texttype || desc->dsc_ttype() == ttype_binary || desc->dsc_ttype() == ttype_none)
{
stuff(statement, blr_varying2);
stuff_word(statement, desc->dsc_ttype());
}
else
{
stuff(statement, blr_varying2); // automatic transliteration
stuff_word(statement, ttype_dynamic);
}
stuff_word(statement, desc->dsc_length - sizeof(USHORT));
break;
case dtype_short:
stuff(statement, blr_short);
stuff(statement, desc->dsc_scale);
break;
case dtype_long:
stuff(statement, blr_long);
stuff(statement, desc->dsc_scale);
break;
case dtype_quad:
stuff(statement, blr_quad);
stuff(statement, desc->dsc_scale);
break;
case dtype_int64:
stuff(statement, blr_int64);
stuff(statement, desc->dsc_scale);
break;
case dtype_real:
stuff(statement, blr_float);
break;
case dtype_double:
stuff(statement, blr_double);
break;
case dtype_sql_date:
stuff(statement, blr_sql_date);
break;
case dtype_sql_time:
stuff(statement, blr_sql_time);
break;
case dtype_timestamp:
stuff(statement, blr_timestamp);
break;
case dtype_array:
stuff(statement, blr_quad);
stuff(statement, 0);
break;
case dtype_blob:
stuff(statement, blr_blob2);
stuff_word(statement, desc->dsc_sub_type);
stuff_word(statement, desc->getTextType());
break;
default:
// don't understand dtype
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_dsql_datatype_err));
}
}
/**
gen_error_condition
@brief Generate blr for an error condtion
@param statement
@param node
**/
static void gen_error_condition( CompiledStatement* statement, const dsql_nod* node)
{
const dsql_str* string;
switch (node->nod_type)
{
case nod_sqlcode:
stuff(statement, blr_sql_code);
stuff_word(statement, (USHORT)(IPTR) node->nod_arg[0]);
return;
case nod_gdscode:
stuff(statement, blr_gds_code);
string = (dsql_str*) node->nod_arg[0];
stuff_cstring(statement, string->str_data);
return;
case nod_exception:
stuff(statement, blr_exception);
string = (dsql_str*) node->nod_arg[0];
stuff_cstring(statement, string->str_data);
return;
case nod_default:
stuff(statement, blr_default_code);
return;
default:
fb_assert(false);
return;
}
}
/**
gen_exec_stmt
@brief Generate blr for the EXECUTE STATEMENT clause
@param statement
@param node
**/
static void gen_exec_stmt(CompiledStatement* statement, const dsql_nod* node)
{
if (node->nod_arg[e_exec_stmt_proc_block])
{
stuff(statement, blr_label);
stuff(statement, (int)(IPTR) node->nod_arg[e_exec_stmt_label]->nod_arg[e_label_number]);
}
stuff(statement, blr_exec_stmt);
// counts of input and output parameters
const dsql_nod* temp = node->nod_arg[e_exec_stmt_inputs];
if (temp)
{
stuff(statement, blr_exec_stmt_inputs);
stuff_word(statement, temp->nod_count);
}
temp = node->nod_arg[e_exec_stmt_outputs];
if (temp)
{
stuff(statement, blr_exec_stmt_outputs);
stuff_word(statement, temp->nod_count);
}
// query expression
stuff(statement, blr_exec_stmt_sql);
GEN_expr(statement, node->nod_arg[e_exec_stmt_sql]);
// proc block body
dsql_nod* temp2 = node->nod_arg[e_exec_stmt_proc_block];
if (temp2)
{
stuff(statement, blr_exec_stmt_proc_block);
GEN_statement(statement, temp2);
}
// external data source, user, password and role
gen_optional_expr(statement, blr_exec_stmt_data_src, node->nod_arg[e_exec_stmt_data_src]);
gen_optional_expr(statement, blr_exec_stmt_user, node->nod_arg[e_exec_stmt_user]);
gen_optional_expr(statement, blr_exec_stmt_pwd, node->nod_arg[e_exec_stmt_pwd]);
gen_optional_expr(statement, blr_exec_stmt_role, node->nod_arg[e_exec_stmt_role]);
// statement's transaction behavior
temp = node->nod_arg[e_exec_stmt_tran];
if (temp)
{
stuff(statement, blr_exec_stmt_tran_clone); // transaction parameters equal to current transaction
stuff(statement, (UCHAR)(IPTR) temp->nod_flags);
}
// inherit caller's privileges ?
if (node->nod_arg[e_exec_stmt_privs]) {
stuff(statement, blr_exec_stmt_privs);
}
// inputs
temp = node->nod_arg[e_exec_stmt_inputs];
if (temp)
{
const dsql_nod* const* ptr = temp->nod_arg;
const bool haveNames = ((*ptr)->nod_arg[e_named_param_name] != 0);
if (haveNames)
stuff(statement, blr_exec_stmt_in_params2);
else
stuff(statement, blr_exec_stmt_in_params);
for (const dsql_nod* const* end = ptr + temp->nod_count; ptr < end; ptr++)
{
if (haveNames)
{
const dsql_str* name = (dsql_str*) (*ptr)->nod_arg[e_named_param_name];
stuff_cstring(statement, name->str_data);
}
GEN_expr(statement, (*ptr)->nod_arg[e_named_param_expr]);
}
}
// outputs
temp = node->nod_arg[e_exec_stmt_outputs];
if (temp)
{
stuff(statement, blr_exec_stmt_out_params);
for (size_t i = 0; i < temp->nod_count; ++i) {
GEN_expr(statement, temp->nod_arg[i]);
}
}
stuff(statement, blr_end);
}
/**
gen_field
@brief Generate blr for a field - field id's
are preferred but not for trigger or view blr.
@param statement
@param context
@param field
@param indices
**/
static void gen_field( CompiledStatement* statement, const dsql_ctx* context,
const dsql_fld* field, dsql_nod* indices)
{
// For older clients - generate an error should they try and
// access data types which did not exist in the older dialect
if (statement->req_client_dialect <= SQL_DIALECT_V5)
{
switch (field->fld_dtype)
{
case dtype_sql_date:
case dtype_sql_time:
case dtype_int64:
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-804) <<
Arg::Gds(isc_dsql_datatype_err) <<
Arg::Gds(isc_sql_dialect_datatype_unsupport) <<
Arg::Num(statement->req_client_dialect) <<
Arg::Str(DSC_dtype_tostring(static_cast<UCHAR>(field->fld_dtype))));
break;
default:
// No special action for other data types
break;
}
}
if (indices)
stuff(statement, blr_index);
if (DDL_ids(statement))
{
stuff(statement, blr_fid);
stuff_context(statement, context);
stuff_word(statement, field->fld_id);
}
else
{
stuff(statement, blr_field);
stuff_context(statement, context);
stuff_meta_string(statement, field->fld_name.c_str());
}
if (indices)
{
stuff(statement, indices->nod_count);
dsql_nod** ptr = indices->nod_arg;
for (const dsql_nod* const* end = ptr + indices->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
}
}
/**
gen_for_select
@brief Generate BLR for a SELECT statement.
@param statement
@param for_select
**/
static void gen_for_select( CompiledStatement* statement, const dsql_nod* for_select)
{
dsql_nod* rse = for_select->nod_arg[e_flp_select];
// CVC: Only put a label if this is not singular; otherwise,
// what loop is the user trying to abandon?
if (for_select->nod_arg[e_flp_action])
{
stuff(statement, blr_label);
stuff(statement, (int) (IPTR) for_select->nod_arg[e_flp_label]->nod_arg[e_label_number]);
}
// Generate FOR loop
stuff(statement, blr_for);
if (!for_select->nod_arg[e_flp_action])
{
stuff(statement, blr_singular);
}
gen_rse(statement, rse);
stuff(statement, blr_begin);
// Build body of FOR loop
// Handle write locks
/* CVC: Unused code!
dsql_nod* streams = rse->nod_arg[e_rse_streams];
dsql_ctx* context = NULL;
if (!rse->nod_arg[e_rse_reduced] && streams->nod_count == 1)
{
dsql_nod* item = streams->nod_arg[0];
if (item && (item->nod_type == nod_relation))
context = (dsql_ctx*) item->nod_arg[e_rel_context];
}
*/
dsql_nod* list = rse->nod_arg[e_rse_items];
dsql_nod* list_to = for_select->nod_arg[e_flp_into];
if (list_to)
{
if (list->nod_count != list_to->nod_count)
{
ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-313) <<
Arg::Gds(isc_dsql_count_mismatch));
}
dsql_nod** ptr = list->nod_arg;
dsql_nod** ptr_to = list_to->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++, ptr_to++)
{
stuff(statement, blr_assignment);
GEN_expr(statement, *ptr);
GEN_expr(statement, *ptr_to);
}
}
if (for_select->nod_arg[e_flp_action])
GEN_statement(statement, for_select->nod_arg[e_flp_action]);
stuff(statement, blr_end);
}
/**
gen_gen_id
@brief Generate BLR for gen_id
@param statement
@param node
**/
static void gen_gen_id( CompiledStatement* statement, const dsql_nod* node)
{
stuff(statement, blr_gen_id);
const dsql_str* string = (dsql_str*) node->nod_arg[e_gen_id_name];
stuff_cstring(statement, string->str_data);
GEN_expr(statement, node->nod_arg[e_gen_id_value]);
}
/**
gen_join_rse
@brief Generate a record selection expression
with an explicit join type.
@param statement
@param rse
**/
static void gen_join_rse( CompiledStatement* statement, const dsql_nod* rse)
{
stuff(statement, blr_rs_stream);
stuff(statement, 2);
GEN_expr(statement, rse->nod_arg[e_join_left_rel]);
GEN_expr(statement, rse->nod_arg[e_join_rght_rel]);
const dsql_nod* node = rse->nod_arg[e_join_type];
if (node->nod_type != nod_join_inner)
{
stuff(statement, blr_join_type);
if (node->nod_type == nod_join_left)
stuff(statement, blr_left);
else if (node->nod_type == nod_join_right)
stuff(statement, blr_right);
else
stuff(statement, blr_full);
}
if (rse->nod_arg[e_join_boolean])
{
stuff(statement, blr_boolean);
GEN_expr(statement, rse->nod_arg[e_join_boolean]);
}
stuff(statement, blr_end);
}
/**
gen_map
@brief Generate a value map for a record selection expression.
@param statement
@param map
**/
static void gen_map( CompiledStatement* statement, dsql_map* map)
{
USHORT count = 0;
dsql_map* temp;
for (temp = map; temp; temp = temp->map_next)
temp->map_position = count++;
stuff(statement, blr_map);
stuff_word(statement, count);
for (temp = map; temp; temp = temp->map_next)
{
stuff_word(statement, temp->map_position);
GEN_expr(statement, temp->map_node);
}
}
static void gen_optional_expr(CompiledStatement* statement, const UCHAR code, dsql_nod* node)
{
if (node)
{
stuff(statement, code);
GEN_expr(statement, node);
}
}
/**
gen_parameter
@brief Generate a parameter reference.
@param statement
@param parameter
**/
static void gen_parameter( CompiledStatement* statement, const dsql_par* parameter)
{
const dsql_msg* message = parameter->par_message;
const dsql_par* null = parameter->par_null;
if (null != NULL)
{
stuff(statement, blr_parameter2);
stuff(statement, message->msg_number);
stuff_word(statement, parameter->par_parameter);
stuff_word(statement, null->par_parameter);
return;
}
stuff(statement, blr_parameter);
stuff(statement, message->msg_number);
stuff_word(statement, parameter->par_parameter);
}
/**
gen_plan
@brief Generate blr for an access plan expression.
@param statement
@param plan_expression
**/
static void gen_plan( CompiledStatement* statement, const dsql_nod* plan_expression)
{
// stuff the join type
const dsql_nod* list = plan_expression->nod_arg[1];
if (list->nod_count > 1)
{
if (plan_expression->nod_arg[0])
stuff(statement, blr_merge);
else
stuff(statement, blr_join);
stuff(statement, list->nod_count);
}
// stuff one or more plan items
const dsql_nod* const* ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
const dsql_nod* node = *ptr;
if (node->nod_type == nod_plan_expr)
{
gen_plan(statement, node);
continue;
}
// if we're here, it must be a nod_plan_item
stuff(statement, blr_retrieve);
// stuff the relation--the relation id itself is redundant except
// when there is a need to differentiate the base tables of views
const dsql_nod* arg = node->nod_arg[0];
gen_relation(statement, (dsql_ctx*) arg->nod_arg[e_rel_context]);
// now stuff the access method for this stream
const dsql_str* index_string;
arg = node->nod_arg[1];
switch (arg->nod_type)
{
case nod_natural:
stuff(statement, blr_sequential);
break;
case nod_index_order:
stuff(statement, blr_navigational);
index_string = (dsql_str*) arg->nod_arg[0];
stuff_cstring(statement, index_string->str_data);
if (!arg->nod_arg[1])
break;
// dimitr: FALL INTO, if the plan item is ORDER ... INDEX (...)
case nod_index:
{
stuff(statement, blr_indices);
arg = (arg->nod_type == nod_index) ? arg->nod_arg[0] : arg->nod_arg[1];
stuff(statement, arg->nod_count);
const dsql_nod* const* ptr2 = arg->nod_arg;
for (const dsql_nod* const* const end2 = ptr2 + arg->nod_count; ptr2 < end2; ptr2++)
{
index_string = (dsql_str*) * ptr2;
stuff_cstring(statement, index_string->str_data);
}
break;
}
default:
fb_assert(false);
break;
}
}
}
/**
gen_relation
@brief Generate blr for a relation reference.
@param statement
@param context
**/
static void gen_relation( CompiledStatement* statement, dsql_ctx* context)
{
const dsql_rel* relation = context->ctx_relation;
const dsql_prc* procedure = context->ctx_procedure;
// if this is a trigger or procedure, don't want relation id used
if (relation)
{
if (DDL_ids(statement))
{
if (context->ctx_alias)
stuff(statement, blr_rid2);
else
stuff(statement, blr_rid);
stuff_word(statement, relation->rel_id);
}
else
{
if (context->ctx_alias)
stuff(statement, blr_relation2);
else
stuff(statement, blr_relation);
stuff_meta_string(statement, relation->rel_name.c_str());
}
if (context->ctx_alias)
stuff_meta_string(statement, context->ctx_alias);
stuff_context(statement, context);
}
else if (procedure)
{
if (DDL_ids(statement))
{
stuff(statement, blr_pid);
stuff_word(statement, procedure->prc_id);
}
else
{
if (procedure->prc_name.qualifier.hasData())
{
stuff(statement, blr_procedure2);
stuff_meta_string(statement, procedure->prc_name.qualifier.c_str());
stuff_meta_string(statement, procedure->prc_name.identifier.c_str());
}
else
{
stuff(statement, blr_procedure);
stuff_meta_string(statement, procedure->prc_name.identifier.c_str());
}
}
stuff_context(statement, context);
dsql_nod* inputs = context->ctx_proc_inputs;
if (inputs)
{
stuff_word(statement, inputs->nod_count);
dsql_nod* const* ptr = inputs->nod_arg;
for (const dsql_nod* const* const end = ptr + inputs->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
}
else
stuff_word(statement, 0);
}
}
/**
gen_return
@brief Generate blr for a procedure return.
@param statement
@param procedure
@param eos_flag
**/
void GEN_return(CompiledStatement* statement, const Array<dsql_nod*>& variables, bool eos_flag)
{
if (!eos_flag)
stuff(statement, blr_begin);
stuff(statement, blr_send);
stuff(statement, 1);
stuff(statement, blr_begin);
for (Array<dsql_nod*>::const_iterator i = variables.begin(); i != variables.end(); ++i)
{
const dsql_nod* parameter = *i;
const dsql_var* variable = (dsql_var*) parameter->nod_arg[e_var_variable];
stuff(statement, blr_assignment);
stuff(statement, blr_variable);
stuff_word(statement, variable->var_variable_number);
stuff(statement, blr_parameter2);
stuff(statement, variable->var_msg_number);
stuff_word(statement, variable->var_msg_item);
stuff_word(statement, variable->var_msg_item + 1);
}
stuff(statement, blr_assignment);
stuff(statement, blr_literal);
stuff(statement, blr_short);
stuff(statement, 0);
if (eos_flag)
stuff_word(statement, 0);
else
stuff_word(statement, 1);
stuff(statement, blr_parameter);
stuff(statement, 1);
stuff_word(statement, USHORT(2 * variables.getCount()));
stuff(statement, blr_end);
if (!eos_flag)
{
stuff(statement, blr_stall);
stuff(statement, blr_end);
}
}
/**
gen_rse
@brief Generate a record selection expression.
@param statement
@param rse
**/
static void gen_rse( CompiledStatement* statement, const dsql_nod* rse)
{
if (rse->nod_flags & NOD_SELECT_EXPR_SINGLETON)
{
stuff(statement, blr_singular);
}
stuff(statement, blr_rse);
dsql_nod* list = rse->nod_arg[e_rse_streams];
// Handle source streams
if (list->nod_type == nod_union)
{
stuff(statement, 1);
gen_union(statement, rse);
}
else if (list->nod_type == nod_list)
{
stuff(statement, list->nod_count);
dsql_nod* const* ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
dsql_nod* node = *ptr;
switch (node->nod_type)
{
case nod_relation:
case nod_aggregate:
case nod_join:
GEN_expr(statement, node);
break;
case nod_derived_table:
GEN_expr(statement, node->nod_arg[e_derived_table_rse]);
break;
}
}
}
else
{
stuff(statement, 1);
GEN_expr(statement, list);
}
if (rse->nod_arg[e_rse_lock])
stuff(statement, blr_writelock);
dsql_nod* node;
if ((node = rse->nod_arg[e_rse_first]) != NULL)
{
stuff(statement, blr_first);
GEN_expr(statement, node);
}
if ((node = rse->nod_arg[e_rse_skip]) != NULL)
{
stuff(statement, blr_skip);
GEN_expr (statement, node);
}
if ((node = rse->nod_arg[e_rse_boolean]) != NULL)
{
stuff(statement, blr_boolean);
GEN_expr(statement, node);
}
if ((list = rse->nod_arg[e_rse_sort]) != NULL)
gen_sort(statement, list);
if ((list = rse->nod_arg[e_rse_reduced]) != NULL)
{
stuff(statement, blr_project);
stuff(statement, list->nod_count);
dsql_nod** ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
}
// if the user specified an access plan to use, add it here
if ((node = rse->nod_arg[e_rse_plan]) != NULL)
{
stuff(statement, blr_plan);
gen_plan(statement, node);
}
stuff(statement, blr_end);
}
/**
gen_searched_case
@brief Generate BLR for CASE function (searched)
@param statement
@param node
**/
static void gen_searched_case( CompiledStatement* statement, const dsql_nod* node)
{
// blr_value_if is used for building the case expression
stuff(statement, blr_cast);
GEN_descriptor(statement, &node->nod_desc, true);
const SSHORT count = node->nod_arg[e_searched_case_search_conditions]->nod_count;
dsql_nod* boolean_list = node->nod_arg[e_searched_case_search_conditions];
dsql_nod* results_list = node->nod_arg[e_searched_case_results];
dsql_nod* const* bptr = boolean_list->nod_arg;
dsql_nod* const* rptr = results_list->nod_arg;
for (const dsql_nod* const* const end = bptr + count; bptr < end; bptr++, rptr++)
{
stuff(statement, blr_value_if);
GEN_expr(statement, *bptr);
GEN_expr(statement, *rptr);
}
// else_result
GEN_expr(statement, node->nod_arg[e_searched_case_results]->nod_arg[count]);
}
/**
gen_select
@brief Generate BLR for a SELECT statement.
@param statement
@param rse
**/
static void gen_select( CompiledStatement* statement, dsql_nod* rse)
{
dsql_ctx* context;
fb_assert(rse->nod_type == nod_rse);
// Set up parameter for things in the select list
const dsql_nod* list = rse->nod_arg[e_rse_items];
dsql_nod* const* ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
dsql_par* parameter = MAKE_parameter(statement->req_receive, true, true, 0, *ptr);
parameter->par_node = *ptr;
MAKE_desc(statement, &parameter->par_desc, *ptr, NULL);
}
// Set up parameter to handle EOF
dsql_par* parameter_eof = MAKE_parameter(statement->req_receive, false, false, 0, NULL);
statement->req_eof = parameter_eof;
parameter_eof->par_desc.dsc_dtype = dtype_short;
parameter_eof->par_desc.dsc_scale = 0;
parameter_eof->par_desc.dsc_length = sizeof(SSHORT);
// Save DBKEYs for possible update later
list = rse->nod_arg[e_rse_streams];
if (!rse->nod_arg[e_rse_reduced])
{
dsql_nod* const* ptr2 = list->nod_arg;
for (const dsql_nod* const* const end2 = ptr2 + list->nod_count; ptr2 < end2; ptr2++)
{
dsql_nod* item = *ptr2;
if (item && item->nod_type == nod_relation)
{
context = (dsql_ctx*) item->nod_arg[e_rel_context];
const dsql_rel* relation = context->ctx_relation;
if (relation)
{
// Set up dbkey
dsql_par* parameter = MAKE_parameter(statement->req_receive, false, false, 0, NULL);
parameter->par_dbkey_ctx = context;
parameter->par_desc.dsc_dtype = dtype_text;
parameter->par_desc.dsc_ttype() = ttype_binary;
parameter->par_desc.dsc_length = relation->rel_dbkey_length;
// Set up record version - for post v33 databases
parameter = MAKE_parameter(statement->req_receive, false, false, 0, NULL);
parameter->par_rec_version_ctx = context;
parameter->par_desc.dsc_dtype = dtype_text;
parameter->par_desc.dsc_ttype() = ttype_binary;
parameter->par_desc.dsc_length = relation->rel_dbkey_length / 2;
}
}
}
}
// Generate definitions for the messages
GEN_port(statement, statement->req_receive);
dsql_msg* message = statement->req_send;
if (message->msg_parameter)
GEN_port(statement, message);
else
statement->req_send = NULL;
// If there is a send message, build a RECEIVE
if ((message = statement->req_send) != NULL)
{
stuff(statement, blr_receive);
stuff(statement, message->msg_number);
}
// Generate FOR loop
message = statement->req_receive;
stuff(statement, blr_for);
stuff(statement, blr_stall);
gen_rse(statement, rse);
stuff(statement, blr_send);
stuff(statement, message->msg_number);
stuff(statement, blr_begin);
// Build body of FOR loop
SSHORT constant;
dsc constant_desc;
constant_desc.dsc_dtype = dtype_short;
constant_desc.dsc_scale = 0;
constant_desc.dsc_sub_type = 0;
constant_desc.dsc_flags = 0;
constant_desc.dsc_length = sizeof(SSHORT);
constant_desc.dsc_address = (UCHAR*) & constant;
// Add invalid usage here
stuff(statement, blr_assignment);
constant = 1;
gen_constant(statement, &constant_desc, USE_VALUE);
gen_parameter(statement, statement->req_eof);
for (dsql_par* parameter = message->msg_parameters; parameter; parameter = parameter->par_next)
{
if (parameter->par_node)
{
stuff(statement, blr_assignment);
GEN_expr(statement, parameter->par_node);
gen_parameter(statement, parameter);
}
if (context = parameter->par_dbkey_ctx)
{
stuff(statement, blr_assignment);
stuff(statement, blr_dbkey);
stuff_context(statement, context);
gen_parameter(statement, parameter);
}
if (context = parameter->par_rec_version_ctx)
{
stuff(statement, blr_assignment);
stuff(statement, blr_record_version);
stuff_context(statement, context);
gen_parameter(statement, parameter);
}
}
stuff(statement, blr_end);
stuff(statement, blr_send);
stuff(statement, message->msg_number);
stuff(statement, blr_assignment);
constant = 0;
gen_constant(statement, &constant_desc, USE_VALUE);
gen_parameter(statement, statement->req_eof);
}
/**
gen_simple_case
@brief Generate BLR for CASE function (simple)
@param statement
@param node
**/
static void gen_simple_case( CompiledStatement* statement, const dsql_nod* node)
{
// blr_value_if is used for building the case expression
stuff(statement, blr_cast);
GEN_descriptor(statement, &node->nod_desc, true);
const SSHORT count = node->nod_arg[e_simple_case_when_operands]->nod_count;
dsql_nod* when_list = node->nod_arg[e_simple_case_when_operands];
dsql_nod* results_list = node->nod_arg[e_simple_case_results];
dsql_nod* const* wptr = when_list->nod_arg;
dsql_nod* const* rptr = results_list->nod_arg;
for (const dsql_nod* const* const end = wptr + count; wptr < end; wptr++, rptr++)
{
stuff(statement, blr_value_if);
stuff(statement, blr_eql);
if (wptr == when_list->nod_arg || !node->nod_arg[e_simple_case_case_operand2])
GEN_expr(statement, node->nod_arg[e_simple_case_case_operand]);
else
GEN_expr(statement, node->nod_arg[e_simple_case_case_operand2]);
GEN_expr(statement, *wptr);
GEN_expr(statement, *rptr);
}
// else_result
GEN_expr(statement, node->nod_arg[e_simple_case_results]->nod_arg[count]);
}
/**
gen_sort
@brief Generate a sort clause.
@param statement
@param list
**/
static void gen_sort( CompiledStatement* statement, dsql_nod* list)
{
stuff(statement, blr_sort);
stuff(statement, list->nod_count);
dsql_nod* const* ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
dsql_nod* nulls_placement = (*ptr)->nod_arg[e_order_nulls];
if (nulls_placement)
{
switch (nulls_placement->getSlong())
{
case NOD_NULLS_FIRST:
stuff(statement, blr_nullsfirst);
break;
case NOD_NULLS_LAST:
stuff(statement, blr_nullslast);
break;
}
}
if ((*ptr)->nod_arg[e_order_flag])
stuff(statement, blr_descending);
else
stuff(statement, blr_ascending);
GEN_expr(statement, (*ptr)->nod_arg[e_order_field]);
}
}
/**
gen_statement
@brief Generate BLR for DML statements.
@param statement
@param node
**/
static void gen_statement(CompiledStatement* statement, const dsql_nod* node)
{
dsql_nod* rse = NULL;
const dsql_msg* message = NULL;
bool send_before_for = !(statement->req_flags & REQ_dsql_upd_or_ins);
switch (node->nod_type)
{
case nod_store:
rse = node->nod_arg[e_sto_rse];
break;
case nod_modify:
rse = node->nod_arg[e_mod_rse];
break;
case nod_erase:
rse = node->nod_arg[e_era_rse];
break;
default:
send_before_for = false;
break;
}
if (statement->req_type == REQ_EXEC_PROCEDURE && send_before_for)
{
if ((message = statement->req_receive))
{
stuff(statement, blr_send);
stuff(statement, message->msg_number);
}
}
if (rse)
{
stuff(statement, blr_for);
GEN_expr(statement, rse);
}
if (statement->req_type == REQ_EXEC_PROCEDURE)
{
if ((message = statement->req_receive))
{
stuff(statement, blr_begin);
if (!send_before_for)
{
stuff(statement, blr_send);
stuff(statement, message->msg_number);
}
}
}
dsql_nod* temp;
const dsql_ctx* context;
const dsql_str* name;
switch (node->nod_type)
{
case nod_store:
stuff(statement, node->nod_arg[e_sto_return] ? blr_store2 : blr_store);
GEN_expr(statement, node->nod_arg[e_sto_relation]);
GEN_statement(statement, node->nod_arg[e_sto_statement]);
if (node->nod_arg[e_sto_return]) {
GEN_statement(statement, node->nod_arg[e_sto_return]);
}
break;
case nod_modify:
stuff(statement, node->nod_arg[e_mod_return] ? blr_modify2 : blr_modify);
temp = node->nod_arg[e_mod_source];
context = (dsql_ctx*) temp->nod_arg[e_rel_context];
stuff_context(statement, context);
temp = node->nod_arg[e_mod_update];
context = (dsql_ctx*) temp->nod_arg[e_rel_context];
stuff_context(statement, context);
GEN_statement(statement, node->nod_arg[e_mod_statement]);
if (node->nod_arg[e_mod_return]) {
GEN_statement(statement, node->nod_arg[e_mod_return]);
}
break;
case nod_modify_current:
stuff(statement, node->nod_arg[e_mdc_return] ? blr_modify2 : blr_modify);
context = (dsql_ctx*) node->nod_arg[e_mdc_context];
stuff_context(statement, context);
temp = node->nod_arg[e_mdc_update];
context = (dsql_ctx*) temp->nod_arg[e_rel_context];
stuff_context(statement, context);
GEN_statement(statement, node->nod_arg[e_mdc_statement]);
if (node->nod_arg[e_mdc_return]) {
GEN_statement(statement, node->nod_arg[e_mdc_return]);
}
break;
case nod_erase:
temp = node->nod_arg[e_era_relation];
context = (dsql_ctx*) temp->nod_arg[e_rel_context];
if (node->nod_arg[e_era_return])
{
stuff(statement, blr_begin);
GEN_statement(statement, node->nod_arg[e_era_return]);
stuff(statement, blr_erase);
stuff_context(statement, context);
stuff(statement, blr_end);
}
else
{
stuff(statement, blr_erase);
stuff_context(statement, context);
}
break;
case nod_erase_current:
context = (dsql_ctx*) node->nod_arg[e_erc_context];
if (node->nod_arg[e_erc_return])
{
stuff(statement, blr_begin);
GEN_statement(statement, node->nod_arg[e_erc_return]);
stuff(statement, blr_erase);
stuff_context(statement, context);
stuff(statement, blr_end);
}
else
{
stuff(statement, blr_erase);
stuff_context(statement, context);
}
break;
case nod_exec_procedure:
if (node->nod_arg[e_exe_package])
{
stuff(statement, blr_exec_proc2);
stuff_meta_string(statement, ((dsql_str*) node->nod_arg[e_exe_package])->str_data);
}
else
stuff(statement, blr_exec_proc);
name = (dsql_str*) node->nod_arg[e_exe_procedure];
stuff_meta_string(statement, name->str_data);
// Input parameters
if ( (temp = node->nod_arg[e_exe_inputs]) )
{
stuff_word(statement, temp->nod_count);
dsql_nod** ptr = temp->nod_arg;
const dsql_nod* const* end = ptr + temp->nod_count;
while (ptr < end)
{
GEN_expr(statement, *ptr++);
}
}
else {
stuff_word(statement, 0);
}
// Output parameters
if ( ( temp = node->nod_arg[e_exe_outputs]) )
{
stuff_word(statement, temp->nod_count);
dsql_nod** ptr = temp->nod_arg;
const dsql_nod* const* end = ptr + temp->nod_count;
while (ptr < end)
{
GEN_expr(statement, *ptr++);
}
}
else {
stuff_word(statement, 0);
}
break;
default:
fb_assert(false);
}
if (message) {
stuff(statement, blr_end);
}
}
/**
gen_sys_function
@brief Generate a system defined function.
@param statement
@param node
**/
static void gen_sys_function(CompiledStatement* statement, const dsql_nod* node)
{
stuff(statement, blr_sys_function);
stuff_cstring(statement, ((dsql_str*) node->nod_arg[e_sysfunc_name])->str_data);
const dsql_nod* list;
if ((node->nod_count == e_sysfunc_args + 1) && (list = node->nod_arg[e_sysfunc_args]))
{
stuff(statement, list->nod_count);
dsql_nod* const* ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
}
else
stuff(statement, 0);
}
/**
gen_table_lock
@brief Generate tpb for table lock.
If lock level is specified, it overrrides the transaction lock level.
@param statement
@param tbl_lock
@param lock_level
**/
static void gen_table_lock( CompiledStatement* statement, const dsql_nod* tbl_lock, USHORT lock_level)
{
if (!tbl_lock || tbl_lock->nod_type != nod_table_lock)
return;
const dsql_nod* tbl_names = tbl_lock->nod_arg[e_lock_tables];
SSHORT flags = 0;
if (tbl_lock->nod_arg[e_lock_mode])
flags = tbl_lock->nod_arg[e_lock_mode]->nod_flags;
if (flags & NOD_PROTECTED)
lock_level = isc_tpb_protected;
else if (flags & NOD_SHARED)
lock_level = isc_tpb_shared;
const USHORT lock_mode = (flags & NOD_WRITE) ? isc_tpb_lock_write : isc_tpb_lock_read;
const dsql_nod* const* ptr = tbl_names->nod_arg;
for (const dsql_nod* const* const end = ptr + tbl_names->nod_count; ptr < end; ptr++)
{
if ((*ptr)->nod_type != nod_relation_name)
continue;
stuff(statement, lock_mode);
// stuff table name
const dsql_str* temp = (dsql_str*) ((*ptr)->nod_arg[e_rln_name]);
stuff_cstring(statement, temp->str_data);
stuff(statement, lock_level);
}
}
/**
gen_udf
@brief Generate a user defined function.
@param statement
@param node
**/
static void gen_udf( CompiledStatement* statement, const dsql_nod* node)
{
const dsql_udf* userFunc = (dsql_udf*) node->nod_arg[0];
if (userFunc->udf_name.qualifier.isEmpty())
stuff(statement, blr_function);
else
{
stuff(statement, blr_function2);
stuff_meta_string(statement, userFunc->udf_name.qualifier.c_str());
}
stuff_meta_string(statement, userFunc->udf_name.identifier.c_str());
const dsql_nod* list;
if ((node->nod_count == 3) && (list = node->nod_arg[2]))
{
stuff(statement, list->nod_count);
dsql_nod* const* ptr = list->nod_arg;
for (const dsql_nod* const* const end = ptr + list->nod_count; ptr < end; ptr++)
{
GEN_expr(statement, *ptr);
}
}
else
stuff(statement, 0);
}
/**
gen_union
@brief Generate a union of substreams.
@param statement
@param union_node
**/
static void gen_union( CompiledStatement* statement, const dsql_nod* union_node)
{
if (union_node->nod_arg[0]->nod_flags & NOD_UNION_RECURSIVE) {
stuff(statement, blr_recurse);
}
else {
stuff(statement, blr_union);
}
// Obtain the context for UNION from the first dsql_map* node
dsql_nod* items = union_node->nod_arg[e_rse_items];
dsql_nod* map_item = items->nod_arg[0];
// AB: First item could be a virtual field generated by derived table.
if (map_item->nod_type == nod_derived_field) {
map_item = map_item->nod_arg[e_alias_value];
}
dsql_ctx* union_context = (dsql_ctx*) map_item->nod_arg[e_map_context];
stuff_context(statement, union_context);
// secondary context number must be present once in generated blr
union_context->ctx_flags &= ~CTX_recursive;
dsql_nod* streams = union_node->nod_arg[e_rse_streams];
stuff(statement, streams->nod_count); // number of substreams
dsql_nod** ptr = streams->nod_arg;
for (const dsql_nod* const* const end = ptr + streams->nod_count; ptr < end; ptr++)
{
dsql_nod* sub_rse = *ptr;
gen_rse(statement, sub_rse);
items = sub_rse->nod_arg[e_rse_items];
stuff(statement, blr_map);
stuff_word(statement, items->nod_count);
USHORT count = 0;
dsql_nod** iptr = items->nod_arg;
for (const dsql_nod* const* const iend = iptr + items->nod_count; iptr < iend; iptr++)
{
stuff_word(statement, count);
GEN_expr(statement, *iptr);
count++;
}
}
}
/**
stuff_context
@brief Write a context number into the BLR buffer.
Check for possible overflow.
@param statement
@param context
**/
static void stuff_context(CompiledStatement* statement, const dsql_ctx* context)
{
if (context->ctx_context > MAX_UCHAR) {
ERRD_post(Arg::Gds(isc_too_many_contexts));
}
stuff(statement, context->ctx_context);
if (context->ctx_flags & CTX_recursive)
{
if (context->ctx_recursive > MAX_UCHAR) {
ERRD_post(Arg::Gds(isc_too_many_contexts));
}
stuff(statement, context->ctx_recursive);
}
}
/**
stuff_meta_string
@brief Write out a string in metadata charset with one byte of length.
@param statement
@param string
**/
static void stuff_meta_string(CompiledStatement* statement, const char* string)
{
statement->append_meta_string(string);
}
/**
stuff_word
@brief Cram a word into the blr buffer. If the buffer is getting
ready to overflow, expand it.
@param statement
@param word
**/
static void stuff_word( CompiledStatement* statement, USHORT word)
{
stuff(statement, word);
stuff(statement, word >> 8);
}
View Git Blame Copy Permalink