//____________________________________________________________

//

// PROGRAM: C preprocessor

// MODULE: cme.cpp

// DESCRIPTION: Request expression compiler

//

// 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): ______________________________________.

//

// Mike Nordell - Reduce compiler warnings, buffer ptr bug

// Stephen W. Boyd - Add support for new features

//____________________________________________________________

//

#include "firebird.h"

#include <stdlib.h>

#include <string.h>

#include "ibase.h"

#include "../gpre/gpre.h"

#include "../jrd/intl.h"

#include "../intl/charsets.h"

#include "../gpre/cme_proto.h"

#include "../gpre/cmp_proto.h"

#include "../gpre/gpre_proto.h"

#include "../gpre/gpre_meta.h"

#include "../gpre/movg_proto.h"

#include "../gpre/par_proto.h"

#include "../common/prett_proto.h"

#include "../common/dsc_proto.h"

#include "../gpre/msc_proto.h"

#include "../jrd/align.h"

static void cmp_array(gpre_nod*, gpre_req*);

static void cmp_array_element(gpre_nod*, gpre_req*);

static void cmp_cast(gpre_nod*, gpre_req*);

static void cmp_field(const gpre_nod*, gpre_req*);

static void cmp_literal(const gpre_nod*, gpre_req*);

static void cmp_map(map*, gpre_req*);

static void cmp_plan(const gpre_nod*, gpre_req*);

static void cmp_sdl_dtype(const gpre_fld*, ref*);

static void cmp_udf(gpre_nod*, gpre_req*);

static void cmp_value(const gpre_nod*, gpre_req*);

static void get_dtype_of_case(const gpre_nod*, gpre_fld*);

static void get_dtype_of_list(const gpre_nod*, gpre_fld*);

static USHORT get_string_len(const gpre_fld*);

static void stuff_sdl_dimension(const dim*, ref*, SSHORT);

static void stuff_sdl_element(ref*, const gpre_fld*);

static void stuff_sdl_loops(ref*, const gpre_fld*);

static void stuff_sdl_number(const SLONG, ref*);

//#define STUFF(blr) *request->req_blr++ = (UCHAR) (blr)

//#define STUFF_WORD(blr) STUFF (blr); STUFF (blr >> 8)

//#define STUFF_CSTRING(blr) stuff_cstring (request, blr)

//#define STUFF_SDL(sdl) *reference->ref_sdl++ = (UCHAR) (sdl)

//#define STUFF_SDL_WORD(sdl) STUFF_SDL (sdl); STUFF_SDL (sdl >> 8);

//#define STUFF_SDL_LONG(sdl) STUFF_SDL (sdl); STUFF_SDL (sdl >> 8); STUFF_SDL (sdl >>16); STUFF_SDL (sdl >> 24);

static bool debug_on;

struct op_table

{

nod_t op_type;

UCHAR op_blr;

};

const op_table operators[] =

{

{ nod_eq , blr_eql },

{ nod_equiv , blr_equiv },

{ nod_ge , blr_geq },

{ nod_gt , blr_gtr },

{ nod_le , blr_leq },

{ nod_lt , blr_lss },

{ nod_ne , blr_neq },

{ nod_missing , blr_missing },

{ nod_between , blr_between },

{ nod_and , blr_and },

{ nod_or , blr_or },

{ nod_not , blr_not },

{ nod_matches , blr_matching },

{ nod_starting , blr_starting },

{ nod_containing , blr_containing },

{ nod_plus , blr_add },

{ nod_from , blr_from },

{ nod_via , blr_via },

{ nod_minus , blr_subtract },

{ nod_times , blr_multiply },

{ nod_divide , blr_divide },

{ nod_negate , blr_negate },

{ nod_null , blr_null },

{ nod_user_name , blr_user_name },

//{ count2 }

//{ nod_count, blr_count2 },

{ nod_count , blr_count },

{ nod_max , blr_maximum },

{ nod_min , blr_minimum },

{ nod_average , blr_average },

{ nod_total , blr_total },

{ nod_any , blr_any },

{ nod_unique , blr_unique },

{ nod_agg_count , blr_agg_count2 },

{ nod_agg_count , blr_agg_count },

{ nod_agg_max , blr_agg_max },

{ nod_agg_min , blr_agg_min },

{ nod_agg_total , blr_agg_total },

{ nod_agg_average , blr_agg_average },

{ nod_upcase , blr_upcase },

{ nod_lowcase , blr_lowcase },

{ nod_sleuth , blr_matching2 },

{ nod_concatenate , blr_concatenate },

{ nod_cast , blr_cast },

{ nod_ansi_any , blr_ansi_any },

{ nod_gen_id , blr_gen_id },

{ nod_ansi_all , blr_ansi_all },

{ nod_current_date, blr_current_date },

{ nod_current_time, blr_current_time },

{ nod_current_timestamp, blr_current_timestamp },

{ nod_current_role, blr_current_role },

{ nod_any, 0 }

};

static inline void assign_dtype(gpre_fld* f, const gpre_fld* field)

{

f->fld_dtype = field->fld_dtype;

f->fld_length = field->fld_length;

f->fld_scale = field->fld_scale;

f->fld_precision = field->fld_precision;

f->fld_sub_type = field->fld_sub_type;

f->fld_charset_id = field->fld_charset_id;

f->fld_collate_id = field->fld_collate_id;

f->fld_ttype = field->fld_ttype;

}

// One of d1, d2 is time, the other is date

static inline bool is_date_and_time(const USHORT d1, const USHORT d2)

{

return (d1 == dtype_sql_time && d2 == dtype_sql_date) ||

(d2 == dtype_sql_time && d1 == dtype_sql_date);

}

//____________________________________________________________

//

// Compile a random expression.

//

void CME_expr(gpre_nod* node, gpre_req* request)

{

gpre_ctx* context;

gpre_fld field;

const ref* reference;

switch (node->nod_type)

{

case nod_field:

if (!(reference = (ref*) node->nod_arg[0]))

{

CPR_error("CME_expr: reference missing");

return;

}

cmp_field(node, request);

if (reference->ref_flags & REF_fetch_array)

cmp_array(node, request);

return;

case nod_array:

cmp_array_element(node, request);

return;

case nod_index:

CME_expr(node->nod_arg[0], request);

return;

case nod_value:

cmp_value(node, request);

if ((reference = (ref*) node->nod_arg[0]) && (reference->ref_flags & REF_fetch_array))

{

cmp_array(node, request);

}

return;

case nod_negate:

if (node->nod_arg[0]->nod_type != nod_literal)

break;

case nod_literal:

cmp_literal(node, request);

return;

case nod_like:

{

request->add_byte((node->nod_count == 2) ? blr_like : blr_ansi_like);

gpre_nod** ptr = node->nod_arg;

for (const gpre_nod* const* const end = ptr + node->nod_count; ptr < end; ptr++)

{

CME_expr(*ptr, request);

}

return;

}

case nod_udf:

cmp_udf(node, request);

return;

case nod_gen_id:

{

request->add_byte(blr_gen_id);

const TEXT* p = (TEXT *) (node->nod_arg[1]);

// check if this generator really exists

if (!MET_generator(p, request->req_database))

{

TEXT s[BUFFER_MEDIUM];

snprintf(s, sizeof(s), "generator %s not found", p);

CPR_error(s);

}

request->add_byte(static_cast<int>(strlen(p)));

while (*p)

request->add_byte(*p++);

CME_expr(node->nod_arg[0], request);

return;

}

case nod_cast:

cmp_cast(node, request);

return;

case nod_nullif:

request->add_byte(blr_value_if);

request->add_byte(blr_eql);

CME_expr(node->nod_arg[0], request);

CME_expr(node->nod_arg[1], request);

request->add_byte(blr_null);

CME_expr(node->nod_arg[0], request);

return;

case nod_agg_count:

if (node->nod_arg[0])

{

if (node->nod_arg[1])

request->add_byte(blr_agg_count_distinct);

else

request->add_byte(blr_agg_count2);

CME_expr(node->nod_arg[0], request);

}

else

request->add_byte(blr_agg_count);

return;

// Begin date/time/timestamp support

case nod_extract:

request->add_byte(blr_extract);

switch ((kwwords_t) (IPTR) node->nod_arg[0])

{

case KW_YEAR:

request->add_byte(blr_extract_year);

break;

case KW_MONTH:

request->add_byte(blr_extract_month);

break;

case KW_DAY:

request->add_byte(blr_extract_day);

break;

case KW_HOUR:

request->add_byte(blr_extract_hour);

break;

case KW_MINUTE:

request->add_byte(blr_extract_minute);

break;

case KW_SECOND:

request->add_byte(blr_extract_second);

break;

case KW_WEEKDAY:

request->add_byte(blr_extract_weekday);

break;

case KW_YEARDAY:

request->add_byte(blr_extract_yearday);

break;

default:

CPR_error("CME_expr: Invalid extract part");

}

CME_expr(node->nod_arg[1], request);

return;

// End date/time/timestamp support

// count2

//case nod_count:

// if (node->nod_arg [1])

// break;

//STUFF (blr_count);

//CME_rse (node->nod_arg [0], request);

//return;

case nod_agg_total:

if (node->nod_arg[1])

{

request->add_byte(blr_agg_total_distinct);

}

else

request->add_byte(blr_agg_total);

CME_expr(node->nod_arg[0], request);

return;

case nod_agg_average:

if (node->nod_arg[1])

{

request->add_byte(blr_agg_average_distinct);

}

else

request->add_byte(blr_agg_average);

CME_expr(node->nod_arg[0], request);

return;

case nod_dom_value:

request->add_byte(blr_fid);

request->add_byte(0); // Context

request->add_word(0); // Field id

return;

case nod_map_ref:

{

const mel* element = (mel*) node->nod_arg[0];

context = element->mel_context;

request->add_byte(blr_fid);

request->add_byte(context->ctx_internal);

request->add_word(element->mel_position);

return;

}

case nod_current_connection:

request->add_byte(blr_internal_info);

request->add_byte(blr_literal);

request->add_byte(blr_long);

request->add_byte(0);

request->add_long(INFO_TYPE_CONNECTION_ID);

return;

case nod_current_transaction:

request->add_byte(blr_internal_info);

request->add_byte(blr_literal);

request->add_byte(blr_long);

request->add_byte(0);

request->add_long(INFO_TYPE_TRANSACTION_ID);

return;

case nod_coalesce:

// Begin by casting the result of coalesce to the proper data type

request->add_byte(blr_cast);

get_dtype_of_list(node->nod_arg[0], &field);

CMP_external_field(request, &field);

// Now add the 'if <expr1> is null then[[ if <expr2> is null then] ...]' stuff

for (int i = 0; i < node->nod_arg[0]->nod_count; i++)

{

request->add_byte(blr_value_if);

request->add_byte(blr_missing);

CME_expr(node->nod_arg[0]->nod_arg[i], request);

}

// Add blr_null to return something if all expressions evaluate to null

request->add_byte(blr_null);

// Now add the 'else <exprn>[[ else <exprn - 1>] ...]' stuff

for (int j = node->nod_arg[0]->nod_count - 1; j >= 0; j--)

{

CME_expr(node->nod_arg[0]->nod_arg[j], request);

}

return;

case nod_case:

// Begin by casting the result of case to the proper data type

request->add_byte(blr_cast);

get_dtype_of_case(node, &field);

CMP_external_field(request, &field);

// Now add the WHEN ... THEN ... clauses

for (int i = 0; i < (node->nod_count - 1); i += 2)

{

request->add_byte(blr_value_if);

CME_expr(node->nod_arg[i], request);

CME_expr(node->nod_arg[i + 1], request);

}

// Now add the ELSE clause

if ((node->nod_count % 2) == 1)

{

CME_expr(node->nod_arg[node->nod_count - 1], request);

}

else

{

request->add_byte(blr_null);

}

return;

case nod_case1:

// Begin by casting the result of case to the proper data type

request->add_byte(blr_cast);

get_dtype_of_case(node, &field);

CMP_external_field(request, &field);

// Now add the WHEN ... THEN ... clauses

for (int i = 1; i < (node->nod_count - 1); i += 2)

{

request->add_byte(blr_value_if);

request->add_byte(blr_eql);

CME_expr(node->nod_arg[0], request);

CME_expr(node->nod_arg[i], request);

CME_expr(node->nod_arg[i + 1], request);

}

// Now add the ELSE clause

if ((node->nod_count % 2) == 0)

{

CME_expr(node->nod_arg[node->nod_count - 1], request);

}

else

{

request->add_byte(blr_null);

}

return;

case nod_substring:

request->add_byte(blr_substring);

CME_expr(node->nod_arg[0], request);

// We need to subtract 1 from the FROM value since it is 1 relative

// but blr_substring requires that it be 0 relative.

request->add_byte(blr_subtract);

CME_expr(node->nod_arg[1], request);

request->add_byte(blr_literal);

request->add_byte(blr_long);

request->add_byte(0);

request->add_long(1);

CME_expr(node->nod_arg[2], request);

return;

default:

break;

}

const op_table* nod2blr_operator;

for (nod2blr_operator = operators; nod2blr_operator->op_type != node->nod_type; ++nod2blr_operator)

{

if (!nod2blr_operator->op_blr)

{

CPR_bugcheck("node type not implemented");

return;

}

}

request->add_byte(nod2blr_operator->op_blr);

gpre_nod** ptr = node->nod_arg;

for (const gpre_nod* const* const end = ptr + node->nod_count; ptr < end; ptr++)

CME_expr(*ptr, request);

switch (node->nod_type)

{

case nod_any:

case nod_ansi_any:

case nod_ansi_all:

case nod_unique:

// count2 next line would be deleted

case nod_count:

CME_rse(node->nod_arg[0], request);

break;

case nod_max:

case nod_min:

case nod_average:

case nod_total:

case nod_from:

//

// case nod_count:

//

CME_rse(node->nod_arg[0], request);

CME_expr(node->nod_arg[1], request);

break;

case nod_via:

CME_rse(node->nod_arg[0], request);

CME_expr(node->nod_arg[1], request);

CME_expr(node->nod_arg[2], request);

default:

break;

}

}

//____________________________________________________________

//

// Compute datatype, length, and scale of an expression.

//

void CME_get_dtype(const gpre_nod* node, gpre_fld* f)

{

gpre_fld field1, field2;

SSHORT dtype_max;

const TEXT* string;

const ref* reference;

const gpre_fld* tmp_field;

const udf* a_udf;

f->fld_dtype = 0;

f->fld_length = 0;

f->fld_scale = 0;

f->fld_sub_type = 0;

f->fld_charset_id = CS_NONE;

f->fld_collate_id = COLLATE_NONE;

f->fld_ttype = CS_NONE;;

switch (node->nod_type)

{

case nod_null:

// This occurs when SQL statement specifies a literal NULL, eg:

// SELECT NULL FROM TABLE1;

// As we don't have a <dtype_null, HOSTTYPE> datatype pairing,

// we don't know how to map this NULL to a host-language

// datatype. Therefore we now describe it as a

// CHAR(1) CHARACTER SET NONE type.

// No value will ever be sent back, as the value of the select

// will be NULL - this is only for purposes of allocating

// values in the message DESCRIBING

// the statement.

// Other parts of gpre aren't too happy with a dtype_unknown datatype

f->fld_dtype = dtype_text;

f->fld_length = 1;

f->fld_ttype = ttype_none;

f->fld_charset_id = CS_NONE;

return;

case nod_map_ref:

{

const mel* element = (mel*) node->nod_arg[0];

CME_get_dtype(element->mel_expr, f);

return;

}

case nod_value:

case nod_field:

case nod_array:

reference = (ref*) node->nod_arg[0];

if (!(tmp_field = reference->ref_field))

CPR_error("CME_get_dtype: node type not supported");

if (!tmp_field->fld_dtype || !tmp_field->fld_length)

PAR_error("Inappropriate self-reference of field");

assign_dtype(f, tmp_field);

return;

case nod_agg_count:

case nod_count:

f->fld_dtype = dtype_long;

f->fld_length = sizeof(SLONG);

return;

case nod_gen_id:

if (gpreGlob.sw_sql_dialect == SQL_DIALECT_V5 || gpreGlob.sw_server_version < 6)

{

f->fld_dtype = dtype_long;

f->fld_length = sizeof(SLONG);

}

else

{

f->fld_dtype = dtype_int64;

f->fld_length = sizeof(ISC_INT64);

}

return;

case nod_max:

case nod_min:

case nod_from:

CME_get_dtype(node->nod_arg[1], f);

return;

case nod_agg_max:

case nod_agg_min:

case nod_negate:

CME_get_dtype(node->nod_arg[0], f);

if (gpreGlob.sw_sql_dialect == SQL_DIALECT_V5 && f->fld_dtype == dtype_int64)

{

f->fld_precision = 0;

f->fld_scale = 0;

f->fld_dtype = dtype_double;

f->fld_length = sizeof(double);

}

return;

// Begin date/time/timestamp support

case nod_extract:

{

const kwwords_t kw_word = (kwwords_t) (IPTR) node->nod_arg[0];

CME_get_dtype(node->nod_arg[1], f);

switch (f->fld_dtype)

{

case dtype_timestamp:

break;

case dtype_sql_date:

if (kw_word == KW_HOUR || kw_word == KW_MINUTE || kw_word == KW_SECOND)

{

CPR_error("Invalid extract part for SQL DATE type");

}

break;

case dtype_sql_time:

if (kw_word != KW_HOUR && kw_word != KW_MINUTE && kw_word != KW_SECOND)

{

CPR_error("Invalid extract part for SQL TIME type");

}

break;

default:

CPR_error("Invalid use of EXTRACT function");

}

switch (kw_word)

{

case KW_YEAR:

case KW_MONTH:

case KW_DAY:

case KW_WEEKDAY:

case KW_YEARDAY:

case KW_HOUR:

case KW_MINUTE:

f->fld_dtype = dtype_short;

f->fld_length = sizeof(short);

break;

case KW_SECOND:

f->fld_dtype = dtype_long;

f->fld_length = sizeof(long);

f->fld_scale = ISC_TIME_SECONDS_PRECISION_SCALE;

break;

default:

CPR_error("Invalid EXTRACT part");

}

return;

}

case nod_current_date:

f->fld_dtype = dtype_sql_date;

f->fld_length = sizeof(ISC_DATE);

return;

case nod_current_time:

f->fld_dtype = dtype_sql_time;

f->fld_length = sizeof(ISC_TIME);

return;

case nod_current_timestamp:

f->fld_dtype = dtype_timestamp;

f->fld_length = sizeof(ISC_TIMESTAMP);

return;

// End date/time/timestamp support

case nod_times:

CME_get_dtype(node->nod_arg[0], &field1);

CME_get_dtype(node->nod_arg[1], &field2);

if (gpreGlob.sw_sql_dialect == SQL_DIALECT_V5)

{

if (field1.fld_dtype == dtype_int64)

{

field1.fld_dtype = dtype_double;

field1.fld_scale = 0;

field1.fld_length = sizeof(double);

}

if (field2.fld_dtype == dtype_int64)

{

field2.fld_dtype = dtype_double;

field2.fld_scale = 0;

field2.fld_length = sizeof(double);

}

dtype_max = MAX(field1.fld_dtype, field2.fld_dtype);

if (DTYPE_IS_DATE(dtype_max) || DTYPE_IS_BLOB(dtype_max))

{

CPR_error("Invalid use of date/blob/array value");

}

}

else

{

dtype_max = DSC_multiply_result[field1.fld_dtype][field2.fld_dtype];

if (dtype_max == dtype_unknown)

{

CPR_error("Invalid operand used in multiplication");

}

else if (dtype_max == DTYPE_CANNOT)

{

CPR_error("expression evaluation not supported");

}

}

switch (dtype_max)

{

case dtype_short:

case dtype_long:

f->fld_dtype = dtype_long;

f->fld_scale = field1.fld_scale + field2.fld_scale;

f->fld_length = sizeof(SLONG);

break;

case dtype_int64:

f->fld_dtype = dtype_int64;

f->fld_scale = field1.fld_scale + field2.fld_scale;

f->fld_length = sizeof(ISC_INT64);

break;

default:

f->fld_dtype = dtype_double;

f->fld_scale = 0;

f->fld_length = sizeof(double);

break;

}

return;

case nod_concatenate:

CME_get_dtype(node->nod_arg[0], &field1);

CME_get_dtype(node->nod_arg[1], &field2);

dtype_max = MAX(field1.fld_dtype, field2.fld_dtype);

if (field1.fld_dtype > dtype_any_text)

{

f->fld_dtype = dtype_cstring;

f->fld_char_length = get_string_len(&field1) + get_string_len(&field2);

f->fld_length = f->fld_char_length + sizeof(USHORT);

f->fld_charset_id = CS_ASCII;

f->fld_ttype = ttype_ascii;

return;

}

assign_dtype(f, &field1);

f->fld_length = get_string_len(&field1) + get_string_len(&field2);

if (f->fld_dtype == dtype_cstring)

f->fld_length += 1;

else if (f->fld_dtype == dtype_varying)

f->fld_length += sizeof(USHORT);

return;

case nod_plus:

case nod_minus:

CME_get_dtype(node->nod_arg[0], &field1);

CME_get_dtype(node->nod_arg[1], &field2);

if (gpreGlob.sw_sql_dialect == SQL_DIALECT_V5)

{

if (field1.fld_dtype == dtype_int64)

{

field1.fld_dtype = dtype_double;

field1.fld_scale = 0;

field1.fld_length = sizeof(double);

}

if (field2.fld_dtype == dtype_int64)

{

field2.fld_dtype = dtype_double;

field2.fld_scale = 0;

field2.fld_length = sizeof(double);

}

if (DTYPE_IS_DATE(field1.fld_dtype) && DTYPE_IS_DATE(field2.fld_dtype) &&

!(node->nod_type == nod_minus || is_date_and_time(field1.fld_dtype, field2.fld_dtype)))

{

CPR_error("Invalid use of timestamp/date/time value");

return; // silence non initialized warning

}

dtype_max = MAX(field1.fld_dtype, field2.fld_dtype);

if (DTYPE_IS_BLOB(dtype_max))

{

CPR_error("Invalid use of blob/array value");

return; // silence non initialized warning

}

}

else

{

// Dialect is > 1

if (node->nod_type == nod_plus)

dtype_max = DSC_add_result[field1.fld_dtype][field2.fld_dtype];

else

dtype_max = DSC_sub_result[field1.fld_dtype][field2.fld_dtype];

if (dtype_max == dtype_unknown)

{

CPR_error("Illegal operands used in addition");

return; // silence non initialized warning

}

if (dtype_max == DTYPE_CANNOT)

{

CPR_error("expression evaluation not supported");

return; // silence non initialized warning

}

}

switch (dtype_max)

{

case dtype_short:

case dtype_long:

f->fld_dtype = dtype_long;

f->fld_scale = MIN(field1.fld_scale, field2.fld_scale);

f->fld_length = sizeof(SLONG);

break;

// Begin date/time/timestamp support

case dtype_sql_date:

f->fld_dtype = dtype_sql_date;

f->fld_scale = 0;

f->fld_length = sizeof(ISC_DATE);

break;

case dtype_sql_time:

f->fld_dtype = dtype_sql_time;

f->fld_scale = 0;

f->fld_length = sizeof(ISC_TIME);

break;

case dtype_timestamp:

f->fld_dtype = dtype_timestamp;

f->fld_scale = 0;

f->fld_length = sizeof(ISC_TIMESTAMP);

break;

// End date/time/timestamp support

case dtype_int64:

f->fld_dtype = dtype_int64;

f->fld_scale = MIN(field1.fld_scale, field2.fld_scale);

f->fld_length = sizeof(ISC_INT64);

break;

default:

f->fld_dtype = dtype_double;

f->fld_scale = 0;

f->fld_length = sizeof(double);

break;

}

return;

case nod_via:

CME_get_dtype(node->nod_arg[1], &field1);

CME_get_dtype(node->nod_arg[2], &field2);

if (field1.fld_dtype >= field2.fld_dtype)

{

assign_dtype(f, &field1);

}

else

{

assign_dtype(f, &field2);

}

return;

case nod_divide:

CME_get_dtype(node->nod_arg[0], &field1);

CME_get_dtype(node->nod_arg[1], &field2);

if (gpreGlob.sw_sql_dialect == SQL_DIALECT_V5)

{

if (field1.fld_dtype == dtype_int64)

{

field1.fld_dtype = dtype_double;

field1.fld_scale = 0;

field1.fld_length = sizeof(double);

}

if (field2.fld_dtype == dtype_int64)

{

field2.fld_dtype = dtype_double;

field2.fld_scale = 0;

field2.fld_length = sizeof(double);

}

dtype_max = MAX(field1.fld_dtype, field2.fld_dtype);

if (DTYPE_IS_DATE(dtype_max) || DTYPE_IS_BLOB(dtype_max))

CPR_error("Invalid use of date/blob/array value");

f->fld_dtype = dtype_double;

f->fld_length = sizeof(double);

return;

}

dtype_max = DSC_multiply_result[field1.fld_dtype][field2.fld_dtype];

if (dtype_max == dtype_unknown)

CPR_error("Illegal operands used in division");

else if (dtype_max == DTYPE_CANNOT)

CPR_error("expression evaluation not supported");

if (dtype_max == dtype_int64)

{

f->fld_dtype = dtype_int64;

f->fld_scale = field1.fld_scale + field2.fld_scale;

f->fld_length = sizeof(ISC_INT64);

}

else

{

f->fld_dtype = dtype_double;

f->fld_scale = 0;

f->fld_length = sizeof(double);

}

return;

case nod_average:

case nod_agg_average:

if (node->nod_type == nod_average)

CME_get_dtype(node->nod_arg[1], f);

else

CME_get_dtype(node->nod_arg[0], f);

if (!DTYPE_IS_NUMERIC(f->fld_dtype))

CPR_error("expression evaluation not supported");

if (gpreGlob.sw_sql_dialect != SQL_DIALECT_V5)

{

if (DTYPE_IS_EXACT(f->fld_dtype))

{

f->fld_dtype = dtype_int64;

f->fld_length = sizeof(SINT64);

}

else

{

f->fld_dtype = dtype_double;

f->fld_length = sizeof(double);

}

}

return;

case nod_agg_total:

case nod_total:

if (node->nod_type == nod_total)

CME_get_dtype(node->nod_arg[1], f);

else

CME_get_dtype(node->nod_arg[0], f);

if (gpreGlob.sw_sql_dialect == SQL_DIALECT_V5)

{

if ((f->fld_dtype == dtype_short) || (f->fld_dtype == dtype_long))

{

f->fld_dtype = dtype_long;

f->fld_length = sizeof(SLONG);

}

else

{

f->fld_precision = 0;

f->fld_scale = 0;

f->fld_dtype = dtype_double;

f->fld_length = sizeof(double);

}

}

else

{

// Dialect is 2 or 3

if (DTYPE_IS_EXACT(f->fld_dtype))

{

f->fld_dtype = dtype_int64;

f->fld_length = sizeof(SINT64);

}

else

{

f->fld_dtype = dtype_double;

f->fld_length = sizeof(double);

}

}

return;

case nod_literal:

reference = (ref*) node->nod_arg[0];

string = reference->ref_value;

if (*string != '"' && *string != '\'')

{

// Value didn't start with a quotemark - must be a numeric

// that we stuffed away as a string during the parse

if (strpbrk(string, "Ee"))

{

f->fld_dtype = dtype_double;

f->fld_length = sizeof(double);

}

else

{

int scale = 0;

const char* s_ptr = string;

// Get the scale

const char* ptr = strpbrk(string, ".");

if (ptr)

{

scale = static_cast<int>((string + (strlen(string) - 1)) - ptr);

scale = -scale;

}

// Get rid of the decimal point

FB_UINT64 uint64_val = 0;

while (*s_ptr)

{

if (*s_ptr != '.')

uint64_val = (uint64_val * 10) + (*s_ptr - '0');

s_ptr++;

}

if (uint64_val <= MAX_SLONG)

{

f->fld_dtype = dtype_long;

f->fld_scale = scale;

f->fld_length = sizeof(SLONG);

}

else

{

f->fld_dtype = dtype_int64;

f->fld_scale = scale;