dsql.c

firebird源代码

RESTORE_THREAD_DATA;

return GDS_DSQL_SQL_INFO (user_status, req_handle, item_length, items,
    buffer_length, buffer);
}

STATUS DLL_EXPORT GDS_DSQL_SET_CURSOR (
    STATUS	*user_status,
    REQ		*req_handle,
    TEXT	*input_cursor,
    USHORT	type)
{
/*****************************************
 *
 *	d s q l _ s e t _ c u r s o r _ n a m e
 *
 **************************************
 *
 * Functional Description
 *	Set a cursor name for a dynamic request
 *
 *****************************************/
REQ		request;
SYM		symbol;
USHORT		length;
struct tsql	thd_context, *tdsql;
JMP_BUF		env;
TEXT		cursor[132];


SET_THREAD_DATA;

ERROR_INIT (env);
init (NULL_PTR);

request = *req_handle;
tdsql->tsql_default = request->req_pool;
if (input_cursor[0] == '\"')
    {
    /** Quoted cursor names eh? Strip'em.
	Note that "" will be replaced with ".
    **/
    int ij;
    for (ij=0; *input_cursor; input_cursor++)
	{
	if (*input_cursor == '\"')
	        input_cursor++;
	cursor [ij++] = *input_cursor;
	}
    cursor[ij] = 0;
    }
else
    {
    USHORT i;
    for (i=0; i < sizeof(cursor)-1		/* PJPG 20001013 */
              && input_cursor[i]		/* PJPG 20001013 */
              && input_cursor[i] != ' '; i++)	/* PJPG 20001013 */
	cursor [i] = UPPER7 (input_cursor [i]);
    cursor [i] = '\0';
    }
length = name_length (cursor);

if (length == 0)
    ERRD_post (gds__sqlerr, gds_arg_number, (SLONG) -502,
        gds_arg_gds, gds__dsql_decl_err,
	0);

/* If there already is a different cursor by the same name, bitch */

if (symbol = HSHD_lookup (request->req_dbb, cursor, length, SYM_cursor, 0))
    {
    if (request->req_cursor == symbol)
	RETURN_SUCCESS;
    else
	ERRD_post (gds__sqlerr, gds_arg_number, (SLONG) -502,
	    gds_arg_gds, gds__dsql_decl_err,
	    0);
    }

/* If there already is a cursor and its name isn't the same, ditto.
   We already know there is no cursor by this name in the hash table */

if (!request->req_cursor)
    request->req_cursor = MAKE_symbol (request->req_dbb, cursor,
	length, SYM_cursor, request);
else
    {
    assert (request->req_cursor != symbol);
    ERRD_post (gds__sqlerr, gds_arg_number, (SLONG) -502,
        gds_arg_gds, gds__dsql_decl_err,
	0);
    };

RETURN_SUCCESS;
}

STATUS DLL_EXPORT GDS_DSQL_SQL_INFO (
    STATUS	*user_status,
    REQ		*req_handle,
    USHORT	item_length,
    SCHAR	*items,
    USHORT	info_length,
    SCHAR	*info)
{
/**************************************
 *
 *	d s q l _ s q l _ i n f o
 *
 **************************************
 *
 * Functional description
 *	Provide information on dsql statement
 *
 **************************************/
REQ		request;
MSG		*message;
SCHAR		item, *end_items, *end_info, *end_describe, buffer [256], *buffer_ptr;
USHORT		length, number, first_index;
struct tsql	thd_context, *tdsql;
JMP_BUF		env;

SET_THREAD_DATA;

ERROR_INIT (env);
init (NULL_PTR);
memset (buffer, 0, sizeof(buffer));

request = *req_handle;

end_items = items + item_length;
end_info = info + info_length;

message = NULL;
first_index = 0;

while (items < end_items && *items != gds__info_end)
    {
    item = *items++;
    if (item == gds__info_sql_select || item == gds__info_sql_bind)
	{
	message = (item == gds__info_sql_select) ?
	    &request->req_receive : &request->req_send;
	if (info + 1 >= end_info)
	    {
	    *info = gds__info_truncated;
	    RETURN_SUCCESS;
	    }
	*info++ = item;
	}
    else if (item == gds__info_sql_stmt_type)
	{
	switch (request->req_type)
	    {
	    case REQ_SELECT:
	    case REQ_EMBED_SELECT:
		number = gds__info_sql_stmt_select;
		break;
	    case REQ_SELECT_UPD:
		number = gds__info_sql_stmt_select_for_upd;
		break;
	    case REQ_DDL:
		number = gds__info_sql_stmt_ddl;
		break;
	    case REQ_GET_SEGMENT:
		number = gds__info_sql_stmt_get_segment;
		break;
	    case REQ_PUT_SEGMENT:
		number = gds__info_sql_stmt_put_segment;
		break;
	    case REQ_COMMIT:
	    case REQ_COMMIT_RETAIN:
		number = gds__info_sql_stmt_commit;
		break;
	    case REQ_ROLLBACK:
		number = gds__info_sql_stmt_rollback;
		break;
	    case REQ_START_TRANS:
		number = gds__info_sql_stmt_start_trans;
		break;
	    case REQ_INSERT:
		number = gds__info_sql_stmt_insert;
		break;
	    case REQ_UPDATE:
	    case REQ_UPDATE_CURSOR:
		number = gds__info_sql_stmt_update;
		break;
	    case REQ_DELETE:
	    case REQ_DELETE_CURSOR:
		number = gds__info_sql_stmt_delete;
		break;
	    case REQ_EXEC_PROCEDURE:
		number = gds__info_sql_stmt_exec_procedure;
		break;
	    case REQ_SET_GENERATOR:
		number = isc_info_sql_stmt_set_generator;
		break;
	    default:
		number = 0;
		break;
	    }
	length = convert ((SLONG) number, buffer);
	if (!(info = put_item (item, length, buffer, info, end_info)))
	    {
	    RETURN_SUCCESS;
	    }
	}
    else if (item == gds__info_sql_sqlda_start)
	{
	length = *items++;
	first_index = gds__vax_integer (items, length);
	items += length;
	}
    else if (item == isc_info_sql_batch_fetch)
	{
	if (request->req_flags & REQ_no_batch)
	    number = FALSE;
	else
	    number = TRUE;
	length = convert ((SLONG) number, buffer);
	if (!(info = put_item (item, length, buffer, info, end_info)))
	    {
	    RETURN_SUCCESS;
	    }
	}
    else if (item == gds__info_sql_records)
	{
        length = get_request_info (request, (SSHORT) sizeof (buffer), buffer);
	if (length && !(info = put_item (item, length, buffer, info, end_info)))
	    {
	    RETURN_SUCCESS;
	    }
	}
    else if (item == gds__info_sql_get_plan)
	{
	/* be careful, get_plan_info() will reallocate the buffer to a
	   larger size if it is not big enough */

	buffer_ptr = buffer;
        length = get_plan_info (request, (SSHORT) sizeof (buffer), &buffer_ptr);

	if (length)
	    info = put_item (item, length, buffer_ptr, info, end_info);

	if (length > sizeof (buffer))
	    gds__free (buffer_ptr);

	if (!info)
	    RETURN_SUCCESS;
	}
    else if (!message ||
	(item != gds__info_sql_num_variables && item != gds__info_sql_describe_vars))
	{
	buffer [0] = item;
	item = gds__info_error;
	length = 1 + convert ((SLONG) gds__infunk, buffer + 1);
	if (!(info = put_item (item, length, buffer, info, end_info)))
	    {
	    RETURN_SUCCESS;
	    }
	}
    else
	{
	number = (*message) ? (*message)->msg_index : 0;
	length = convert ((SLONG) number, buffer);
	if (!(info = put_item (item, length, buffer, info, end_info)))
	    {
	    RETURN_SUCCESS;
	    }
	if (item == gds__info_sql_num_variables)
	    continue;

	end_describe = items;
	while (end_describe < end_items &&
	    *end_describe != gds__info_end &&
	    *end_describe != gds__info_sql_describe_end)
	    end_describe++;

	if (!(info = var_info (*message, items, end_describe, info, end_info, first_index)))
	    {
	    RETURN_SUCCESS;
	    }

	items = end_describe;
	if (*items == gds__info_sql_describe_end)
	    items++;
	}
    }

*info++ = gds__info_end;

RETURN_SUCCESS;
}

#ifdef DEV_BUILD
void DSQL_pretty (
    NOD		node,
    int		column)
{
/**************************************
 *
 *	D S Q L _ p r e t t y
 *
 **************************************
 *
 * Functional description
 *	Pretty print a node tree.
*
 **************************************/
MAP	map;
NOD	*ptr, *end;
DSQL_REL	relation;
CTX	context;
FLD	field;
STR	string;
VAR	variable;
#ifdef STACK_REDUCTION
TEXT	*buffer, *p, *verb, s[64];
#else
TEXT	buffer [1024], *p, *verb, s[64];
#endif
USHORT 	l;

#ifdef STACK_REDUCTION
buffer = (TEXT *) gds__alloc (BUFFER_LARGE);
#endif

p = buffer;
sprintf (p, "%.7X ", node);
while (*p)
    p++;

if ((l = column * 3) != NULL)
    do *p++ = ' '; while (--l);

*p = 0;

if (!node)
    {
    PRINTF ("%s *** null ***\n", buffer);
    FREE_MEM_RETURN;
    }

switch (node->nod_header.blk_type)
    {
    case (TEXT) type_str:
	PRINTF ("%sSTRING: \"%s\"\n", buffer, ((STR) node)->str_data);
	FREE_MEM_RETURN;

    case (TEXT) type_fld:
	PRINTF ("%sFIELD: %s\n", buffer, ((FLD) node)->fld_name);
	FREE_MEM_RETURN;

    case (TEXT) type_sym:
	PRINTF ("%sSYMBOL: %s\n", buffer, ((SYM) node)->sym_string);
	FREE_MEM_RETURN;

    case (TEXT) type_nod:
	break;

    default:
	PRINTF ("%sUNKNOWN BLOCK TYPE\n", buffer);
	FREE_MEM_RETURN;
    }

ptr = node->nod_arg;
end = ptr + node->nod_count;

switch (node->nod_type)
    {
    case nod_abort:	verb = "abort";		break;
    case nod_agg_average: verb = "agg_average";	break;
    case nod_agg_count:	verb = "agg_count";	break;
/* count2
    case nod_agg_distinct: verb = "agg_distinct";	break;
*/
    case nod_agg_item:	verb = "agg_item";	break;
    case nod_agg_max:	verb = "agg_max";	break;
    case nod_agg_min:	verb = "agg_min";	break;
    case nod_agg_total:	verb = "agg_total";	break;
    case nod_add:	verb = "add";		break;
    case nod_alias:	verb = "alias";		break;
    case nod_ansi_all:
    case nod_all:	verb = "all";		break;
    case nod_and:	verb = "and";		break;
    case nod_ansi_any:
    case nod_any:	verb = "any";		break;
    case nod_array:	verb = "array element";	break;
    case nod_assign:	verb = "assign";	break;
    case nod_average: 	verb = "average";	break;
    case nod_between:	verb = "between";	break;
    case nod_cast:	verb = "cast";		break;
    case nod_close:	verb = "close";		break;
    case nod_collate:	verb = "collate";	break;
    case nod_concatenate: verb = "concatenate";	break;
    case nod_containing: verb = "containing";	break;
    case nod_count:	verb = "count";		break;
    case nod_current_date:	verb = "current_date";		break;
    case nod_current_time:	verb = "current_time";		break;
    case nod_current_timestamp:	verb = "current_timestamp";	break;
    case nod_cursor:		verb = "cursor";		break;
    case nod_dbkey:		verb = "dbkey";			break;
    case nod_rec_version:	verb = "record_version";	break;
    case nod_def_database:	verb = "define database"; 	break;
    case nod_def_field:		verb = "define field"; 		break;
    case nod_def_generator:     verb = "define generator";      break;
    case nod_def_filter:        verb = "define filter";         break;
    case nod_def_index:		verb = "define index"; 		break;
    case nod_def_relation:	verb = "define relation"; 	break;

	/* CVC: New node redef_relation. */
	case nod_redef_relation:    verb = "redefine relation";     break;

    case nod_def_view:		verb = "define view"; 		break;
    case nod_delete:		verb = "delete";		break;
    case nod_del_field:		verb = "delete field";		break;
    case nod_del_filter:        verb = "delete filter";         break;
    case nod_del_generator:     verb = "delete generator";      break;
    case nod_del_index:		verb = "delete index";		break;
    case nod_del_relation:	verb = "delete relation";	break;

    /* CVC: New node del_view. */
    case nod_del_view:		verb = "delete view";		break;

    case nod_def_procedure:	verb = "define procedure";	break;

	 /* CVC: New node redef_procedure. */
	 case nod_redef_procedure:	verb = "redefine procedure"; break;
    case nod_del_procedure:	verb = "delete porcedure";	break;
    case nod_def_trigger:	verb = "define trigger";	break;
    case nod_mod_trigger:	verb = "modify trigger";	break;
    case nod_del_trigger:	verb = "delete trigger";	break;
    case nod_divide:	verb = "divide";	break;
    case nod_eql_all:
    case nod_eql_any:
    case nod_eql:	verb = "eql";		break;
    case nod_erase:	verb = "erase";		break;
    case nod_execute:   verb = "execute";       break;
    case nod_exec_procedure:   verb = "execute procedure";       break;
    case nod_exec_sql:  verb = "execute varchar";               break;
    case nod_exists:	verb = "exists";	break;
    case nod_extract:   verb = "extract";	break;
    case nod_fetch:	verb = "fetch";		break;
    case nod_flag:	verb = "flag";		break;
    case nod_for:	verb = "for";		break;
    case nod_foreign:	verb = "foreign key";	break;
    case nod_gen_id:     verb = "gen_id";        break;
    case nod_geq_all:
    case nod_geq_any:
    case nod_geq:	verb = "geq";		break;
    case nod_get_segment:	verb = "get segment";		break;
    case nod_grant:	verb = "grant";		break;
    case nod_gtr_all:
    case nod_gtr_any:
    case nod_gtr:	verb = "gtr";		break;
    case nod_insert:	verb = "insert";	break;
    case nod_join:	verb = "join";		break;
    case nod_join_full:	verb = "join_full";	break;
    case nod_join_left:	verb = "join_left";	break;
    case nod_join_right:verb = "join_right";	break;
    case nod_leq_all:
    case nod_leq_any:
    case nod_leq:	verb = "leq";		break;
    case nod_like:	verb = "like";		break;
    case nod_list:	verb = "list";		break;
    case nod_lss_all:
    case nod_lss_any:
    case nod_lss:	verb = "lss";		break;
    case nod_max:	verb = "max";		break;
    case nod_min:	verb = "min";		break;
    case nod_missing:	verb = "missing";	break;
    case nod_modify:	verb = "modify";	break;
    case nod_mod_database:	verb = "modify database"; 	break;
    case nod_mod_field:	verb = "modify field";	break;
    case nod_mod_relation:	verb = "modify relation";	break;
    case nod_multiply:	verb = "multiply";	break;
    case nod_negate:	verb = "negate";	break;
    case nod_neq_all:
    case nod_neq_any:
    case nod_neq:	verb = "neq";		break;
    case nod_not:	verb = "not";		break;
    case nod_null:	verb = "null";		break;
    case nod_open:	verb = "open";		break;
    case nod_or:	verb = "or";		break;
    case nod_order:	verb = "order";		break;
    case nod_parameter: verb = "parameter";	break;
    case nod_primary:	verb = "primary key";	break;
    case nod_procedure_name:    verb = "procedure name";        break;
    case nod_put_segment:	verb = "put segment";		break;
    case nod_relation_name:	verb = "relation name";	break;
    case nod_rel_proc_name:	verb = "rel/proc name";	break;
    case nod_retrieve:	verb = "retrieve";	break;
    case nod_return:	verb = "return";	break;
    case nod_revoke:	verb = "revoke";	break;
    case nod_rse:	verb = "rse";		break;
    case nod_select:	verb = "select";	break;
    case nod_select_expr: verb = "select expr";	break;
    case nod_starting:	verb = "starting";	break;
    case nod_store:	verb = "store";		break;
    case nod_substr:	verb = "substr";	break;
    case nod_subtract:	verb = "subtract";	break;
    case nod_total:	verb = "total";		break;
    case nod_update:	verb = "update";	break;
    case nod_union:	verb = "union";		break;
    case nod_unique:	verb = "unique";	break;
    case nod_upcase:	verb = "upcase";	break;
    case nod_singular:	verb = "singular";	break;
    case nod_user_name:	verb = "user_name";	break;

    /* CVC: New node current_role. */
    case nod_current_role:	verb = "current_role";	break;

    case nod_values:	verb = "values";	break;
    case nod_via:	verb = "via";		break;

    case nod_add2:	verb = "add2";		break;