firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-27 05:23:02 +01:00
Code Issues
6ce5e8d8f3
firebird-mirror/src/qli/meta.epp
alexpeshkoff d63491e3c5 Finished gcc-warnings cleanup
2007-04-11 16:05:40 +00:00

3647 lines
89 KiB
Plaintext
Raw Blame History

/*
* PROGRAM: JRD Command Oriented Query Language
* MODULE: meta.epp
* DESCRIPTION: Meta-data interface
*
* 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): ______________________________________.
*/
#include "firebird.h"
#include <stdio.h>
#include <string.h>
#include "../qli/dtr.h"
#include "../qli/compile.h"
#include "../qli/exe.h"
//#include "../jrd/license.h"
#include "../jrd/flags.h"
#include "../jrd/ibase.h"
#include "../qli/reqs.h"
#include "../qli/all_proto.h"
#include "../qli/err_proto.h"
#include "../qli/gener_proto.h"
#include "../qli/hsh_proto.h"
#include "../qli/meta_proto.h"
#include "../gpre/prett_proto.h"
#include "../jrd/gds_proto.h"
#include "../jrd/isc_f_proto.h"
#include "../jrd/utl_proto.h"
#include "../common/utils_proto.h"
#include "../common/classes/ClumpletWriter.h"
#include "../common/classes/UserBlob.h"
using MsgFormat::SafeArg;
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
DATABASE DB = FILENAME "yachts.lnk";
DATABASE DB1 = FILENAME "yachts.lnk";
static void add_field(qli_rel*, qli_fld*, USHORT);
static void add_sql_field(qli_rel*, qli_fld*, USHORT, qli_rlb*);
static void blob_copy(qli_rlb*, qli_rel*, ISC_QUAD&);
static void change_field(qli_rel*, qli_fld*);
static bool check_global_field(DBB, qli_fld*, const TEXT*);
static bool check_relation(qli_rel*);
static void clone_fields(qli_rel*, qli_rel*);
static void clone_global_fields(qli_rel*, qli_rel*);
static void define_global_field(DBB, qli_fld*, qli_symbol*);
static void delete_fields(qli_rel*);
static ISC_STATUS detach(ISC_STATUS *, DBB);
static void execute_dynamic_ddl(DBB, qli_rlb*);
static int field_length(USHORT, USHORT);
static void get_database_type(DBB);
static TEXT *get_query_header(DBB, ISC_QUAD&);
static void install(dbb*);
static qli_syntax* make_node(NOD_T, USHORT);
static TEXT *make_string(TEXT*, SSHORT);
static qli_symbol* make_symbol(TEXT *, SSHORT);
static qli_const* missing_value(ISC_QUAD&, qli_symbol*);
static qli_syntax* parse_blr(UCHAR **, qli_symbol*);
static qli_syntax* parse_blr_blob(ISC_QUAD&, qli_symbol*);
static void purge_relation(qli_rel*);
static void put_dyn_string(qli_rlb*, const TEXT*);
static void rollback_update(DBB);
static void set_capabilities(DBB);
static DBB setup_update(DBB);
static void sql_grant_revoke(qli_syntax*, USHORT);
static void stuff_priv(qli_rlb*, USHORT, const TEXT*, USHORT, const TEXT*, const TEXT*);
static int truncate_string(TEXT*);
static const UCHAR tpb[] = { isc_tpb_version1, isc_tpb_write };
static const UCHAR db_info[] = { isc_info_implementation, isc_info_end };
static UCHAR global_parm_buffer[256];
/*
static const UCHAR dpb_trace [] = { isc_dpb_version1, isc_dpb_trace, 1, 1 };
static const UCHAR dpb_num_buffers [ ] = { isc_dpb_version1, isc_dpb_num_buffers, 1, 1 };
*/
#define STUFF_STRING(str) put_dyn_string (rlb, str)
#define BLR_BYTE *blr++
static const USHORT blr_dtypes[] =
{
0,
blr_text,
blr_text,
blr_varying,
0,
0,
0,
0,
blr_short,
blr_long,
blr_quad,
blr_float,
blr_double,
blr_double,
blr_sql_date,
blr_sql_time,
blr_timestamp,
blr_blob,
0,
blr_int64
};
/*
table used to determine capabilities, checking for specific
fields in system relations
*/
struct rfr_tab_t {
const TEXT* relation;
const TEXT* field;
int bit_mask;
};
static const rfr_tab_t rfr_table[] =
{
{ "RDB$INDICES", "RDB$INDEX_INACTIVE", DBB_cap_idx_inactive },
/* OBSOLETE - 1996-Aug-06 David Schnepper
{ "RDB$RELATIONS", "RDB$STORE_TRIGGER", DBB_cap_triggers },
*/
{ "RDB$RELATIONS", "RDB$EXTERNAL_FILE", DBB_cap_extern_file },
{ "RDB$SECURITY_CLASSES", "RDB$SECURITY_CLASS", DBB_cap_security },
{ "RDB$FILES", "RDB$FILE_NAME", DBB_cap_files },
{ "RDB$FUNCTIONS", "RDB$FUNCTION_NAME", DBB_cap_functions },
{ "RDB$TRIGGERS", "RDB$TRIGGER_BLR", DBB_cap_new_triggers },
{ "RDB$CONSTRAINTS", "RDB$CONSTRAINT_NAME", DBB_cap_single_trans },
{ "RDB$FILES", "RDB$SHADOW_NUMBER", DBB_cap_shadowing },
{ "RDB$TYPES", "RDB$TYPE_NAME", DBB_cap_types },
{ "RDB$FIELDS", "RDB$DIMENSIONS", DBB_cap_dimensions },
{ "RDB$FIELDS", "RDB$EXTERNAL_TYPE", DBB_cap_external_type },
{ "RDB$RELATION_FIELDS", "RDB$SYSTEM_FLAG", DBB_cap_rfr_sys_flag },
{ "RDB$FILTERS", "RDB$FUNCTION_NAME", DBB_cap_filters },
{ "RDB$INDICES", "RDB$INDEX_TYPE", DBB_cap_index_type },
{ 0, 0, 0 }
};
bool MET_declare( DBB database, qli_fld* variable, const nam* field_name)
{
/**************************************
*
* M E T _ d e c l a r e
*
**************************************
*
* Functional description
* Find a global field referenced in a DECLARE.
*
**************************************/
if (!database)
database = QLI_databases;
for (; database; database = database->dbb_next) {
MET_meta_transaction(database, false);
if (check_global_field(database, variable, field_name->nam_string))
return true;
}
return false;
}
void MET_define_field( DBB database, qli_fld* field)
{
/**************************************
*
* M E T _ d e f i n e _ f i e l d
*
**************************************
*
* Functional description
* Define a new global field.
*
**************************************/
database = setup_update(database);
if (check_global_field(database, NULL, field->fld_name->sym_string)) {
rollback_update(database);
ERRQ_print_error(233, field->fld_name->sym_string);
// Msg233 global field %s already exists
}
define_global_field(database, field, field->fld_name);
MET_meta_commit(database);
}
void MET_define_index( qli_syntax* node)
{
/**************************************
*
* M E T _ d e f i n e _ i n d e x
*
**************************************
*
* Functional description
* Define a new index.
*
**************************************/
qli_symbol* symbol = (qli_symbol*) node->syn_arg[s_dfi_name];
qli_rel* relation = (qli_rel*) node->syn_arg[s_dfi_relation];
qli_syntax* fields = node->syn_arg[s_dfi_fields];
DBB database = setup_update(relation->rel_database);
if (relation->rel_flags & REL_view)
IBERROR(234); // Msg234 Can't define an index in a view
FOR(REQUEST_HANDLE database->dbb_requests[REQ_def_index1])
X IN DB.RDB$INDICES WITH X.RDB$INDEX_NAME EQ symbol->sym_string
ERRQ_print_error(235, symbol->sym_string);
// Msg235 Index %s already exists
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
STORE(REQUEST_HANDLE database->dbb_requests[REQ_def_index2])
X IN DB.RDB$INDICES
strcpy(X.RDB$RELATION_NAME, relation->rel_symbol->sym_string);
strcpy(X.RDB$INDEX_NAME, symbol->sym_string);
X.RDB$UNIQUE_FLAG = (node->syn_flags & s_dfi_flag_unique);
X.RDB$INDEX_INACTIVE = (node->syn_flags & s_dfi_flag_inactive);
X.RDB$SEGMENT_COUNT = fields->syn_count;
X.RDB$INDEX_TYPE =
(node->syn_flags & s_dfi_flag_descending) ? TRUE : FALSE;
END_STORE
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
/* at this point force garbage collection of any index segments left over
from previous failures. The system transaction (which might notice them
later does NOT recognize rolled back stuff! Should someone have actually
left an orphanned segment around, kill that too.
*/
FOR(REQUEST_HANDLE database->dbb_requests[REQ_scan_index])
X IN DB.RDB$INDEX_SEGMENTS WITH X.RDB$INDEX_NAME = symbol->sym_string
ERASE X
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
NAM* ptr = (NAM*) fields->syn_arg;
for (int position = 0; position < fields->syn_count; ptr++, position++)
{
MET_fields(relation);
bool present = false;
for (qli_fld* field = relation->rel_fields; field;
field = field->fld_next)
{
if (!(strcmp((*ptr)->nam_string, field->fld_name->sym_string))) {
present = true;
break;
}
}
if (!present) {
rollback_update(database);
ERRQ_print_error(236, SafeArg() << (*ptr)->nam_string <<
relation->rel_symbol->sym_string);
// Msg236 Field %s does not occur in relation %s
}
setup_update(database);
STORE(REQUEST_HANDLE database->dbb_requests[REQ_def_index3])
X IN DB.RDB$INDEX_SEGMENTS
strcpy(X.RDB$INDEX_NAME, symbol->sym_string);
strcpy(X.RDB$FIELD_NAME, (*ptr)->nam_string);
X.RDB$FIELD_POSITION = position;
END_STORE
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
}
MET_meta_commit(database);
}
void MET_define_relation( qli_rel* relation, qli_rel* source)
{
/**************************************
*
* M E T _ d e f i n e _ r e l a t i o n
*
**************************************
*
* Functional description
* Define a new relation. There may
* be field definitions here or we may
* copy the field definitions from somebody
* else.
*
**************************************/
qli_symbol* symbol = relation->rel_symbol;
if (source) {
source->rel_database = setup_update(source->rel_database);
if (!(check_relation(source)))
ERRQ_print_error(483, source->rel_symbol->sym_string);
// Msg 483 Relation %s does not exist
}
DBB database = setup_update(relation->rel_database);
relation->rel_database = database;
if (check_relation(relation))
ERRQ_print_error(237, symbol->sym_string); // Msg237 Relation %s already exists
STORE(REQUEST_HANDLE database->dbb_requests[REQ_store_relation])
X IN DB.RDB$RELATIONS
strcpy(X.RDB$RELATION_NAME, symbol->sym_string);
END_STORE
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
if (source)
clone_fields(relation, source);
else {
USHORT position = 1;
for (qli_fld* field = relation->rel_fields; field;
field = field->fld_next, position++)
{
add_field(relation, field, position);
}
}
MET_meta_commit(database);
relation = (qli_rel*) ALLOCP(type_rel);
relation->rel_next = database->dbb_relations;
database->dbb_relations = relation;
relation->rel_database = database;
// Go back and pick up relation id
setup_update(database);
FOR(REQUEST_HANDLE database->dbb_requests[REQ_relation_id])
X IN DB.RDB$RELATIONS WITH X.RDB$RELATION_NAME EQ symbol->sym_string
relation->rel_id = X.RDB$RELATION_ID;
symbol = make_symbol(X.RDB$RELATION_NAME, sizeof(X.RDB$RELATION_NAME));
symbol->sym_type = SYM_relation;
symbol->sym_object = (BLK) relation;
relation->rel_symbol = symbol;
HSH_insert(symbol);
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
delete_fields(relation);
MET_fields(relation);
}
void MET_define_sql_relation( qli_rel* relation)
{
/**************************************
*
* M E T _ d e f i n e _ s q l _ r e l a t i o n
*
**************************************
*
* Functional description
* Define a new SQL relation, using dynamic ddl.
*
**************************************/
qli_symbol* symbol = relation->rel_symbol;
DBB database = setup_update(relation->rel_database);
relation->rel_database = database;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_relation_def])
X IN DB.RDB$RELATIONS WITH X.RDB$RELATION_NAME EQ symbol->sym_string
ERRQ_print_error(237, symbol->sym_string);
// Msg237 Relation %s already exists
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
qli_rlb* rlb = NULL;
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_begin);
STUFF(isc_dyn_def_rel);
STUFF_STRING(symbol->sym_string);
STUFF(isc_dyn_rel_sql_protection);
STUFF_WORD(2);
STUFF_WORD(1);
USHORT position = 1;
for (qli_fld* field = relation->rel_fields; field;
field = field->fld_next, position++)
{
add_sql_field(relation, field, position, rlb);
}
STUFF(isc_dyn_end);
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
execute_dynamic_ddl(database, rlb);
MET_meta_commit(database);
relation = (qli_rel*) ALLOCP(type_rel);
relation->rel_next = database->dbb_relations;
database->dbb_relations = relation;
relation->rel_database = database;
// Go back and pick up relation id
setup_update(database);
FOR(REQUEST_HANDLE database->dbb_requests[REQ_relation_id])
X IN DB.RDB$RELATIONS WITH X.RDB$RELATION_NAME EQ symbol->sym_string
relation->rel_id = X.RDB$RELATION_ID;
symbol =
make_symbol(X.RDB$RELATION_NAME, sizeof(X.RDB$RELATION_NAME));
symbol->sym_type = SYM_relation;
symbol->sym_object = (BLK) relation;
relation->rel_symbol = symbol;
HSH_insert(symbol);
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
delete_fields(relation);
MET_fields(relation);
}
void MET_delete_database( DBB dbb)
{
/**************************************
*
* M E T _ d e l e t e _ d a t a b a s e
*
**************************************
*
* Functional description
* Drop an existing database, and all its files,
* and finish any copies we have active.
*
**************************************/
/* generate a database parameter block to
include the user/password, if necessary */
const TEXT* user;
USHORT user_length;
if (dbb->dbb_user) {
user = (TEXT *) dbb->dbb_user->con_data;
user_length = dbb->dbb_user->con_desc.dsc_length;
}
else {
user = QLI_default_user;
user_length = strlen(QLI_default_user);
}
const TEXT* password;
USHORT password_length;
if (dbb->dbb_password) {
password = (TEXT *) dbb->dbb_password->con_data;
password_length = dbb->dbb_user->con_desc.dsc_length;
}
else {
password = QLI_default_password;
password_length = strlen(QLI_default_password);
}
Firebird::ClumpletWriter dpb(Firebird::ClumpletReader::Tagged, MAX_DPB_SIZE, isc_dpb_version1);
if (user_length) {
dpb.insertString(isc_dpb_user_name, user, user_length);
}
if (password_length) {
dpb.insertString(isc_dpb_password, password, password_length);
}
ISC_STATUS_ARRAY status_vector;
if (isc_attach_database(status_vector, 0, dbb->dbb_filename,
&dbb->dbb_handle, dpb.getBufferLength(),
reinterpret_cast<const char*>(dpb.getBuffer())))
ERRQ_database_error(dbb, status_vector);
qli_lls* stack = NULL;
gds_trans = MET_transaction(nod_start_trans, dbb);
DB = dbb->dbb_handle;
FOR F IN DB.RDB$FILES SORTED BY F.RDB$FILE_START
qli_str* astring = (qli_str*) ALLOCDV(type_str, strlen(F.RDB$FILE_NAME));
strcpy(astring->str_data, F.RDB$FILE_NAME);
ALLQ_push((blk*) astring, &stack);
END_FOR
ON_ERROR
ERRQ_database_error(dbb, gds_status);
END_ERROR;
MET_transaction(nod_commit, dbb);
if (isc_detach_database(gds_status, &dbb->dbb_handle))
isc_print_status(gds_status);
DBB next = NULL;
for (DBB database = QLI_databases; database; database = next) {
next = database->dbb_next;
if (!strcmp(database->dbb_filename, dbb->dbb_filename))
MET_finish(database);
}
while (stack) {
qli_str* sstring = (qli_str*) ALLQ_pop(&stack);
if (unlink(sstring->str_data))
ERRQ_print_error(431, sstring->str_data);
// Msg431 Could not drop database file "%s"
}
if (unlink(dbb->dbb_filename))
ERRQ_print_error(431, dbb->dbb_filename);
// Msg431 Could not drop database file "%s"
}
void MET_delete_field( DBB database, NAM name)
{
/**************************************
*
* M E T _ d e l e t e _ f i e l d
*
**************************************
*
* Functional description
* Delete a global field.
*
**************************************/
database = setup_update(database);
USHORT count = 0;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_check_fld])
RFR IN DB.RDB$RELATION_FIELDS
WITH RFR.RDB$FIELD_SOURCE EQ name->nam_string
REDUCED TO RFR.RDB$RELATION_NAME
if (!count)
ERRQ_msg_put(238, name->nam_string); // Msg238 Field %s is in use in the following relations:
printf("\t%s\n", RFR.RDB$RELATION_NAME);
count++;
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
if (count)
ERRQ_print_error(239, SafeArg() << name->nam_string << database->dbb_filename);
// Msg239 Field %s is in use in database %s
FOR(REQUEST_HANDLE database->dbb_requests[REQ_erase_fld])
FLD IN DB.RDB$FIELDS WITH FLD.RDB$FIELD_NAME EQ name->nam_string
qli_rlb* rlb = NULL;
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_delete_dimensions);
STUFF_STRING(FLD.RDB$FIELD_NAME);
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
execute_dynamic_ddl(database, rlb);
ERASE FLD
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
count++;
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
if (!count)
ERRQ_print_error(240, SafeArg() << name->nam_string << database->dbb_filename);
// Msg240 Field %s is not defined in database %s
MET_meta_commit(database);
}
void MET_delete_index( DBB database, NAM name)
{
/**************************************
*
* M E T _ d e l e t e _ i n d e x
*
**************************************
*
* Functional description
* Delete an index.
*
**************************************/
database = setup_update(database);
USHORT count = 0;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_erase_index])
IDX IN DB.RDB$INDICES WITH IDX.RDB$INDEX_NAME EQ name->nam_string
count++;
ERASE IDX
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
if (!count)
ERRQ_print_error(241, SafeArg() << name->nam_string << database->dbb_filename);
// Msg241 Index %s is not defined in database %s
FOR(REQUEST_HANDLE database->dbb_requests[REQ_erase_segments])
SEG IN DB.RDB$INDEX_SEGMENTS WITH SEG.RDB$INDEX_NAME EQ name->nam_string
ERASE SEG
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
MET_meta_commit(database);
}
void MET_delete_relation( qli_rel* relation)
{
/**************************************
*
* M E T _ d e l e t e _ r e l a t i o n
*
**************************************
*
* Functional description
* Delete a relation.
*
**************************************/
// Pass the mess off to dynamic DDL and let it worry
qli_symbol* symbol = relation->rel_symbol;
qli_rlb* rlb = NULL;
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_delete_rel);
STUFF_STRING(symbol->sym_string);
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
setup_update(relation->rel_database);
execute_dynamic_ddl(relation->rel_database, rlb);
MET_meta_commit(relation->rel_database);
// Unlink and release various blocks
purge_relation(relation);
}
int MET_dimensions( DBB database, const TEXT* field_name)
{
/**************************************
*
* M E T _ d i m e n s i o n s
*
**************************************
*
* Functional description
* Determine if the field has any dimensions.
*
**************************************/
if (!(database->dbb_capabilities & DBB_cap_dimensions))
return 0;
USHORT dimensions = 0;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_fld_dimensions])
F IN DB.RDB$FIELDS WITH F.RDB$FIELD_NAME = field_name
dimensions = F.RDB$DIMENSIONS;
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
return dimensions;
}
void MET_fields( qli_rel* relation)
{
/**************************************
*
* M E T _ f i e l d s
*
**************************************
*
* Functional description
* Get all fields for a relation.
*
**************************************/
/* If we already have fetched the fields for the relation,
don't do it again. */
if (relation->rel_flags & REL_fields)
return;
DBB database = relation->rel_database;
MET_meta_transaction(database, false);
relation->rel_flags |= REL_fields;
qli_fld** ptr = &relation->rel_fields;
FOR(REQUEST_HANDLE database->dbb_field_request)
RFR IN DB.RDB$RELATION_FIELDS CROSS
RFL IN DB.RDB$FIELDS WITH
RFR.RDB$FIELD_SOURCE EQ RFL.RDB$FIELD_NAME AND
RFR.RDB$RELATION_NAME EQ relation->rel_symbol->sym_string
SORTED BY RFR.RDB$FIELD_POSITION, RFR.RDB$FIELD_NAME;
if (RFR.RDB$FIELD_POSITION > relation->rel_max_field_pos)
relation->rel_max_field_pos = RFR.RDB$FIELD_POSITION;
qli_fld* field = (qli_fld*) ALLOCPV(type_fld, 0);
*ptr = field;
ptr = &field->fld_next;
field->fld_relation = relation;
qli_symbol* symbol = make_symbol(RFR.RDB$FIELD_NAME, sizeof(RFR.RDB$FIELD_NAME));
if (symbol) {
symbol->sym_object = (BLK) field;
symbol->sym_type = SYM_field;
field->fld_name = symbol;
}
if ((symbol = make_symbol(RFR.RDB$QUERY_NAME, sizeof(RFR.RDB$QUERY_NAME))) ||
(symbol = make_symbol(RFL.RDB$QUERY_NAME, sizeof(RFL.RDB$QUERY_NAME))))
{
symbol->sym_object = (BLK) field;
symbol->sym_type = SYM_field;
field->fld_query_name = symbol;
}
field->fld_scale = RFL.RDB$FIELD_SCALE;
field->fld_id = RFR.RDB$FIELD_ID;
if (RFL.RDB$SEGMENT_LENGTH.NULL)
field->fld_segment_length = 80;
else {
field->fld_segment_length =
((RFL.RDB$SEGMENT_LENGTH) < 256
&& (RFL.RDB$SEGMENT_LENGTH >
0)) ? RFL.RDB$SEGMENT_LENGTH : 255;
}
ISC_QUAD* blob = & RFR.RDB$QUERY_HEADER;
if (UserBlob::blobIsNull(*blob))
blob = & RFL.RDB$QUERY_HEADER;
if (!UserBlob::blobIsNull(*blob))
field->fld_query_header = get_query_header(database, *blob);
blob = & RFL.RDB$COMPUTED_BLR;
if (!UserBlob::blobIsNull(*blob))
field->fld_flags |= FLD_computed;
field->fld_dtype = MET_get_datatype(RFL.RDB$FIELD_TYPE);
field->fld_length =
field_length(field->fld_dtype, RFL.RDB$FIELD_LENGTH);
if (field->fld_dtype == dtype_varying)
field->fld_length += sizeof(SSHORT);
field->fld_sub_type = RFL.RDB$FIELD_SUB_TYPE;
field->fld_sub_type_missing = RFL.RDB$FIELD_SUB_TYPE.NULL;
if (!RFL.RDB$MISSING_VALUE.NULL)
field->fld_missing =
missing_value(RFL.RDB$MISSING_VALUE, field->fld_name);
if (!(field->fld_edit_string =
make_string(RFR.RDB$EDIT_STRING, sizeof(RFR.RDB$EDIT_STRING))))
field->fld_edit_string =
make_string(RFL.RDB$EDIT_STRING, sizeof(RFL.RDB$EDIT_STRING));
field->fld_validation =
parse_blr_blob(RFL.RDB$VALIDATION_BLR, field->fld_name);
if (MET_dimensions(database, RFL.RDB$FIELD_NAME) > 0)
field->fld_flags |= FLD_array;
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
}
void MET_finish( DBB dbb)
{
/**************************************
*
* M E T _ f i n i s h
*
**************************************
*
* Functional description
* Finish a database and release all associated blocks.
*
**************************************/
// Get rid of relation and field blocks.
qli_rel* relation;
while (relation = dbb->dbb_relations) {
purge_relation(relation);
}
// Get rid of any functions
qli_fun* function;
while (function = dbb->dbb_functions) {
dbb->dbb_functions = function->fun_next;
HSH_remove(function->fun_symbol);
ALLQ_release((FRB) function->fun_symbol);
ALLQ_release((FRB) function);
}
// Finally, actually close down database connection.
ISC_STATUS_ARRAY status_vector;
detach(status_vector, dbb);
if (dbb->dbb_symbol) {
HSH_remove(dbb->dbb_symbol);
ALLQ_release((FRB) dbb->dbb_symbol);
}
int count = 0;
for (DBB* ptr = &QLI_databases; *ptr; ptr = &(*ptr)->dbb_next)
{
if (*ptr == dbb)
{
*ptr = dbb->dbb_next;
ALLQ_release((FRB) dbb);
count++;
if (!*ptr) {
break;
}
}
}
if (!count)
ERRQ_bugcheck(231); // Msg231 database block not found for removal
if (status_vector[1])
ERRQ_database_error(NULL, status_vector);
}
int MET_get_datatype( USHORT blr_datatype)
{
/**************************************
*
* M E T _ g e t _ d a t a t y p e
*
**************************************
*
* Functional description
* Convert a blr datatype to a QLI dtype.
*
**************************************/
USHORT retvalue;
switch (blr_datatype)
{
case blr_text:
retvalue = dtype_text;
break;
case blr_varying:
retvalue = dtype_varying;
break;
case blr_cstring:
retvalue = dtype_cstring;
break;
case blr_short:
retvalue = dtype_short;
break;
case blr_long:
retvalue = dtype_long;
break;
case blr_quad:
retvalue = dtype_quad;
break;
case blr_float:
retvalue = dtype_real;
break;
case blr_double:
retvalue = dtype_double;
break;
case blr_timestamp:
retvalue = dtype_timestamp;
break;
case blr_sql_date:
retvalue = dtype_sql_date;
break;
case blr_sql_time:
retvalue = dtype_sql_time;
break;
case blr_blob:
retvalue = dtype_blob;
break;
case blr_int64:
retvalue = dtype_int64;
break;
default:
retvalue = dtype_unknown;
break;
}
return retvalue;
}
#ifdef DEV_BUILD
void MET_index_info(const SCHAR* relation_name,
const SCHAR* index_name,
SCHAR* buffer)
{
/**************************************
*
* M E T _ i n d e x _ i n f o
*
**************************************
*
* Functional description
* Get info about a particular index.
*
**************************************/
FB_API_HANDLE request_handle = 0;
SCHAR* b = buffer;
FOR(REQUEST_HANDLE request_handle)
IDX IN DB.RDB$INDICES CROSS
SEG IN DB.RDB$INDEX_SEGMENTS OVER
RDB$INDEX_NAME WITH
IDX.RDB$INDEX_NAME EQ index_name AND
IDX.RDB$RELATION_NAME EQ relation_name
SORTED BY SEG.RDB$FIELD_POSITION
const SCHAR* p;
if (b == buffer) {
// CVC: warning: not dialect 3 aware.
for (p = IDX.RDB$INDEX_NAME; *p && *p != ' ';) {
*b++ = *p++;
}
*b++ = ' ';
*b++ = '(';
}
// CVC: warning: not dialect 3 aware.
for (p = SEG.RDB$FIELD_NAME; *p && *p != ' ';) {
*b++ = *p++;
}
*b++ = ' ';
END_FOR
ON_ERROR
ERRQ_database_error(NULL, gds_status);
END_ERROR;
if (request_handle)
if (isc_release_request(gds_status, &request_handle))
ERRQ_database_error(NULL, gds_status);
// back up over the last space and finish off
b--;
*b++ = ')';
*b++ = 0;
}
#endif
void MET_meta_commit( DBB database)
{
/**************************************
*
* M E T _ m e t a _ c o m m i t
*
**************************************
*
* Functional description
* Commit the meta data lookup & update
* transaction.
*
**************************************/
if (database->dbb_capabilities & DBB_cap_multi_trans)
{
ISC_STATUS_ARRAY status_vector;
if (isc_commit_transaction(status_vector, &database->dbb_meta_trans)) {
rollback_update(database);
ERRQ_database_error(database, status_vector);
}
}
}
void MET_meta_rollback( DBB database)
{
/**************************************
*
* M E T _ m e t a _ r o l l b a c k
*
**************************************
*
* Functional description
* Rollback the metadata transaction,
* if there is one.
*
**************************************/
if (database->dbb_capabilities & DBB_cap_multi_trans)
rollback_update(database);
}
FB_API_HANDLE MET_meta_transaction(DBB database, bool update_flag)
{
/**************************************
*
* M E T _ m e t a _ t r a n s a c t i o n
*
**************************************
*
* Functional description
* Setup transaction for meta-data operation. Set up
* DB and gds_trans, and return meta-data transaction
* handle for yucks. If we're doing metadata updates,
* and lookups we'll use the metadat date transaction,
* unless this is an rdb database or gateway in which
* case, we'll use the only transacti.
*
* In any event, we will set up the met_transaction because
* it's widely used and somebody is going to forget to test
* that the database is multi_transaction before using it.
* This means that we have to be very careful about committing
* or rolling back, because this could affect user data.
*
**************************************/
ISC_STATUS_ARRAY status_vector;
if (!database)
IBERROR(243); // Msg243 no active database for operation
FB_API_HANDLE transaction = (database->dbb_capabilities & DBB_cap_multi_trans) ?
database->dbb_meta_trans : 0;
DB = database->dbb_handle;
/* If we don't know whether or not the database can handle
multiple transactions, find out now */
if (!transaction &&
((database->dbb_capabilities & DBB_cap_multi_trans) ||
!(database->dbb_capabilities & DBB_cap_single_trans)))
{
if (isc_start_transaction(status_vector, &transaction, 1,
&database->dbb_handle, sizeof(tpb), tpb))
{
database->dbb_capabilities |= DBB_cap_single_trans;
}
else
{
database->dbb_capabilities |= DBB_cap_multi_trans;
}
}
// If we already have a meta-data transaction, there's more nothing to do
gds_trans = transaction;
// If we only support a single transaction, use the data transaction
if (!gds_trans && (database->dbb_capabilities & DBB_cap_single_trans))
{
if (update_flag)
IBERROR(244); // Msg244 Interactive metadata updates are not available on Rdb
if (!(gds_trans = database->dbb_transaction))
gds_trans = MET_transaction(nod_start_trans, database);
}
// otherwise make one more effort to start the transaction
else if (!gds_trans)
{
START_TRANSACTION
ON_ERROR
ERRQ_database_error(database, status_vector);
END_ERROR;
}
database->dbb_meta_trans = gds_trans;
return gds_trans;
}
void MET_modify_field( DBB database, qli_fld* field)
{
/**************************************
*
* M E T _ m o d i f y _ f i e l d
*
**************************************
*
* Functional description
* Modify an existing global field.
*
**************************************/
database = setup_update(database);
qli_symbol* field_name = field->fld_name;
SSHORT flag = 0;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_modify_fld])
X IN DB.RDB$FIELDS WITH X.RDB$FIELD_NAME EQ field_name->sym_string
if (field->fld_dtype &&
(X.RDB$FIELD_TYPE == blr_blob || blr_dtypes[field->fld_dtype] == blr_blob) &&
X.RDB$FIELD_TYPE != blr_dtypes[field->fld_dtype])
{
flag = -1;
}
else
{
flag = 1;
MODIFY X USING
if (field->fld_dtype) {
X.RDB$FIELD_TYPE = blr_dtypes[field->fld_dtype];
X.RDB$FIELD_SCALE = field->fld_scale;
X.RDB$FIELD_LENGTH = (field->fld_dtype == dtype_varying) ?
field->fld_length -
sizeof(SSHORT) : field->fld_length;
}
if (!field->fld_sub_type_missing) {
X.RDB$FIELD_SUB_TYPE.NULL = FALSE;
X.RDB$FIELD_SUB_TYPE = field->fld_sub_type;
}
qli_symbol* asymbol = field->fld_query_name;
if (asymbol) {
X.RDB$QUERY_NAME.NULL = FALSE;
strcpy(X.RDB$QUERY_NAME, asymbol->sym_string);
}
if (field->fld_edit_string) {
X.RDB$EDIT_STRING.NULL = FALSE;
strcpy(X.RDB$EDIT_STRING, field->fld_edit_string);
}
END_MODIFY
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
}
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
if (flag <= 0)
{
rollback_update(database);
// Msg245 global field %s is not defined
// Msg468 Datatype of field %s may not be changed to or from blob
const USHORT nErr = flag ? 468 : 245;
ERRQ_print_error(flag, field_name->sym_string);
}
MET_meta_commit(database);
// Now go back and re-fetch fields for affected databases
setup_update(database);
FOR(REQUEST_HANDLE database->dbb_requests[REQ_update_fld])
X IN DB.RDB$RELATION_FIELDS WITH X.RDB$FIELD_SOURCE EQ
field_name->sym_string REDUCED TO X.RDB$RELATION_NAME
const TEXT* p = X.RDB$RELATION_NAME;
while (*p && *p != ' ') {
p++;
}
qli_symbol* symbol = HSH_lookup(X.RDB$RELATION_NAME, p - X.RDB$RELATION_NAME);
for (; symbol; symbol = symbol->sym_homonym)
{
qli_rel* relation;
if (symbol->sym_type == SYM_relation &&
(relation = (qli_rel*) symbol->sym_object) &&
relation->rel_database == database)
{
delete_fields(relation);
MET_fields(relation);
}
}
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
}
void MET_modify_index( qli_syntax* node)
{
/**************************************
*
* M E T _ m o d i f y _ i n d e x
*
**************************************
*
* Functional description
* Change the changeable options
* of an index.
*
**************************************/
NAM name = (NAM) node->syn_arg[s_mfi_name];
DBB database = (DBB) node->syn_arg[s_mfi_database];
database = setup_update(database);
USHORT count = 0;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_mdf_index])
X IN DB.RDB$INDICES WITH X.RDB$INDEX_NAME = name->nam_string
MODIFY X USING
if (node->syn_flags & s_dfi_flag_selectivity)
X.RDB$UNIQUE_FLAG = (node->syn_flags & s_dfi_flag_unique);
if (node->syn_flags & s_dfi_flag_activity)
X.RDB$INDEX_INACTIVE =
(node->syn_flags & s_dfi_flag_inactive);
if (node->syn_flags & s_dfi_flag_order)
X.RDB$INDEX_TYPE =
(node->syn_flags & s_dfi_flag_descending) ? TRUE : FALSE;
if (node->syn_flags & s_dfi_flag_statistics)
X.RDB$STATISTICS = -1.0;
END_MODIFY
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
count++;
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
if (!count)
ERRQ_print_error(246, SafeArg() << name->nam_string << database->dbb_filename);
// Msg246 Index %s does not exist
MET_meta_commit(database);
}
void MET_modify_relation( qli_rel* relation, qli_fld* fields)
{
/**************************************
*
* M E T _ m o d i f y _ r e l a t i o n
*
**************************************
*
* Functional description
* Modify an existing relation.
*
**************************************/
DBB database = setup_update(relation->rel_database);
relation->rel_database = database;
qli_symbol* relation_name = relation->rel_symbol;
for (qli_fld* field = fields; field; field = field->fld_next)
{
if (field->fld_flags & FLD_drop) {
USHORT count = 0;
qli_symbol* field_name = field->fld_name;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_modify_rel])
X IN DB.RDB$RELATION_FIELDS WITH
X.RDB$FIELD_NAME EQ field_name->sym_string AND
X.RDB$RELATION_NAME EQ relation_name->sym_string
count++;
ERASE X
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
if (!count) {
rollback_update(database);
ERRQ_print_error(247, field_name->sym_string); // Msg247 field %s doesn't exist
}
}
else if (field->fld_flags & FLD_modify)
change_field(relation, field);
else
add_field(relation, field, 0);
}
MET_meta_commit(database);
setup_update(database);
delete_fields(relation);
MET_fields(relation);
}
void MET_ready( qli_syntax* node, USHORT create_flag)
{
/**************************************
*
* M E T _ r e a d y
*
**************************************
*
* Functional description
* Create or Ready one or more databases. If any
* fail, all fail. Fair enough?
*
**************************************/
Firebird::ClumpletWriter dpb(Firebird::ClumpletReader::Tagged, MAX_DPB_SIZE, isc_dpb_version1);
DBB temp = (DBB) node->syn_arg[0];
/* Only a SQL CREATE DATABASE will have a pagesize parameter,
so only looking at the first pointer is justified. */
SSHORT length;
const TEXT* lc_ctype = QLI_charset;
if (lc_ctype && (length = strlen(lc_ctype))) {
dpb.insertString(isc_dpb_lc_ctype, lc_ctype, length);
}
if (QLI_trace) {
dpb.insertByte(isc_dpb_trace, 1);
}
if (sw_buffers) {
dpb.insertInt(isc_dpb_num_buffers, ULONG(sw_buffers));
}
if (temp->dbb_pagesize) {
dpb.insertInt(isc_dpb_page_size, ULONG(temp->dbb_pagesize));
}
// get a username, if specified globally or on the command line
const TEXT* q;
if (temp->dbb_user) {
q = (TEXT *) temp->dbb_user->con_data;
length = temp->dbb_user->con_desc.dsc_length;
}
else {
q = QLI_default_user;
length = strlen(QLI_default_user);
}
if (length) {
dpb.insertString(isc_dpb_user_name, q, length);
}
// get a password, if specified
if (temp->dbb_password) {
q = (TEXT *) temp->dbb_password->con_data;
length = temp->dbb_password->con_desc.dsc_length;
}
else {
q = QLI_default_password;
length = strlen(QLI_default_password);
}
if (length) {
dpb.insertString(isc_dpb_password, q, length);
}
#ifdef TRUSTED_AUTH
if (QLI_trusted) {
dpb.insertTag(isc_dpb_trusted_auth);
}
#endif
const qli_syntax* const* const end = node->syn_arg + node->syn_count;
// Start by attaching all databases
ISC_STATUS_ARRAY status_vector;
qli_syntax** ptr;
DBB dbb = 0;
for (ptr = node->syn_arg; ptr < end; ptr++) {
dbb = (DBB) *ptr;
if (create_flag)
isc_create_database(status_vector, 0, dbb->dbb_filename,
&dbb->dbb_handle, dpb.getBufferLength(),
reinterpret_cast<const char*>(dpb.getBuffer()), 0);
else
isc_attach_database(status_vector, 0, dbb->dbb_filename,
&dbb->dbb_handle, dpb.getBufferLength(),
reinterpret_cast<const char*>(dpb.getBuffer()));
if (status_vector[1])
break;
}
// If any attach failed, cleanup and give up
if (ptr < end) {
for (qli_syntax** ptr2 = node->syn_arg; ptr2 < ptr; ptr2++)
detach(gds_status, (DBB) *ptr2);
ERRQ_database_error(dbb, status_vector);
}
// Databases are up and running. Install each.
for (ptr = node->syn_arg; ptr < end; ptr++)
install((DBB) *ptr);
}
void MET_shutdown(void)
{
/**************************************
*
* M E T _ s h u t d o w n
*
**************************************
*
* Functional description
* Shut down all attached databases.
*
**************************************/
ISC_STATUS_ARRAY status_vector;
for (DBB dbb = QLI_databases; dbb; dbb = dbb->dbb_next)
if (detach(status_vector, dbb))
isc_print_status(status_vector);
}
void MET_sql_alter_table( qli_rel* relation, qli_fld* fields)
{
/**************************************
*
* M E T _ s q l _ a l t e r _ t a b l e
*
**************************************
*
* Functional description
* Alter table data based on a SQL metadata request
*
**************************************/
qli_symbol* symbol = relation->rel_symbol;
DBB database = setup_update(relation->rel_database);
relation->rel_database = database;
USHORT count = 0;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_relation_def])
X IN DB.RDB$RELATIONS WITH X.RDB$RELATION_NAME EQ symbol->sym_string
count++;
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
if (!count)
ERRQ_print_error(414, symbol->sym_string); // Msg237 Relation %s is lost
qli_rlb* rlb = NULL;
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_begin);
STUFF(isc_dyn_mod_rel);
STUFF_STRING(symbol->sym_string);
for (qli_fld* field = fields; field; field = field->fld_next) {
if (field->fld_flags & FLD_add)
add_sql_field(relation, field, 0, rlb);
else if (field->fld_flags & FLD_drop) {
STUFF(isc_dyn_delete_local_fld);
STUFF_STRING(field->fld_name->sym_string);
STUFF(isc_dyn_end);
}
}
STUFF(isc_dyn_end);
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
execute_dynamic_ddl(database, rlb);
MET_meta_commit(database);
setup_update(database);
delete_fields(relation);
MET_fields(relation);
}
void MET_sql_cr_view( qli_syntax* node)
{
/**************************************
*
* M E T _ s q l _ c r _ v i e w
*
**************************************
*
* Functional description
* Create a view from a SQL metadata request
*
**************************************/
qli_rel* relation = (qli_rel*) node->syn_arg[s_crv_name];
DBB database = setup_update(relation->rel_database);
relation->rel_database = database;
qli_symbol* symbol = relation->rel_symbol;
qli_rlb* rlb = NULL;
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_begin);
STUFF(isc_dyn_def_view);
STUFF_STRING(symbol->sym_string);
// The meat of the blr generation will go here
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
execute_dynamic_ddl(database, rlb);
MET_meta_commit(database);
}
void MET_sql_grant( qli_syntax* node)
{
/**************************************
*
* M E T _ s q l _ g r a n t
*
**************************************
*
* Functional description
* Grant access privilege(s) on a SQL table
*
**************************************/
sql_grant_revoke(node, isc_dyn_grant);
}
void MET_sql_revoke( qli_syntax* node)
{
/**************************************
*
* M E T _ s q l _ r e v o k e
*
**************************************
*
* Functional description
* Revoke access privilege(s) on a SQL table
*
**************************************/
sql_grant_revoke(node, isc_dyn_revoke);
}
FB_API_HANDLE MET_transaction( NOD_T node_type, DBB database)
{
/**************************************
*
* M E T _ t r a n s a c t i o n
*
**************************************
*
* Functional description
* Finish off a transaction with a commit, prepare, or rollback.
* For commit and rollback, start a new transaction.
*
* Multiple transaction coordination is handled
* by the caller. This is a singleminded routine.
*
**************************************/
ISC_STATUS_ARRAY status_vector;
switch (node_type) {
case nod_commit:
isc_commit_transaction(status_vector, &database->dbb_transaction);
break;
case nod_rollback:
isc_rollback_transaction(status_vector, &database->dbb_transaction);
break;
case nod_prepare:
isc_prepare_transaction(status_vector, &database->dbb_transaction);
break;
case nod_start_trans:
isc_start_transaction(status_vector, &database->dbb_transaction, 1,
&database->dbb_handle, sizeof(tpb), tpb);
database->dbb_flags &= ~DBB_updates & ~DBB_prepared;
break;
}
if (status_vector[1])
ERRQ_database_error(database, status_vector);
return database->dbb_transaction;
}
static void add_field( qli_rel* relation, qli_fld* field, USHORT position)
{
/**************************************
*
* a d d _ f i e l d
*
**************************************
*
* Functional description
* Add a field to a relation. Do all sorts of sanity checks.
*
**************************************/
DBB database = relation->rel_database;
qli_symbol* relation_name = relation->rel_symbol;
qli_symbol* field_name = field->fld_name;
qli_symbol* global_field = field->fld_based;
if (!global_field)
global_field = field_name;
// Check to see if it already exits in relation
FOR(REQUEST_HANDLE database->dbb_requests[REQ_rfr_def])
X IN DB.RDB$RELATION_FIELDS WITH
X.RDB$RELATION_NAME EQ relation_name->sym_string AND
X.RDB$FIELD_NAME EQ field_name->sym_string
rollback_update(relation->rel_database);
ERRQ_print_error(251, SafeArg() << field_name->sym_string <<
relation_name->sym_string);
// Msg251 Field %s already exists in relation %s
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
// Check global field. Define it if it doesn't exist.
bool global_flag = false;
if (!check_global_field(database, field, global_field->sym_string)) {
global_flag = true;
define_global_field(database, field, global_field);
}
/* Finally, store into RFR. If we defined a global field, assume that
the query name and edit string will be inherited from there, otherwise
include them here */
STORE(REQUEST_HANDLE database->dbb_requests[REQ_store_rfr])
X IN DB.RDB$RELATION_FIELDS
strcpy(X.RDB$RELATION_NAME, relation_name->sym_string);
strcpy(X.RDB$FIELD_NAME, field_name->sym_string);
strcpy(X.RDB$FIELD_SOURCE, global_field->sym_string);
if (position) {
X.RDB$FIELD_POSITION.NULL = FALSE;
X.RDB$FIELD_POSITION = position;
}
else
X.RDB$FIELD_POSITION.NULL = TRUE;
const qli_symbol* symbol;
if (!global_flag && (symbol = field->fld_query_name)) {
X.RDB$QUERY_NAME.NULL = FALSE;
strcpy(X.RDB$QUERY_NAME, symbol->sym_string);
}
else
X.RDB$QUERY_NAME.NULL = TRUE;
if (!global_flag && (field->fld_edit_string)) {
X.RDB$EDIT_STRING.NULL = FALSE;
strcpy(X.RDB$EDIT_STRING, field->fld_edit_string);
}
else
X.RDB$EDIT_STRING.NULL = TRUE;
END_STORE
ON_ERROR
rollback_update(relation->rel_database);
ERRQ_database_error(relation->rel_database, gds_status);
END_ERROR;
}
static void add_sql_field( qli_rel* relation, qli_fld* field, USHORT position,
qli_rlb* rlb)
{
/**************************************
*
* a d d _ s q l _ f i e l d
*
**************************************
*
* Functional description
* Add a SQL field to a relation via dyn.
*
**************************************/
rlb = CHECK_RLB(rlb);
DBB database = relation->rel_database;
const qli_symbol* relation_name = relation->rel_symbol;
const qli_symbol* field_name = field->fld_name;
// Check to see if it already exists in relation
FOR(REQUEST_HANDLE database->dbb_requests[REQ_rfr_def])
X IN DB.RDB$RELATION_FIELDS WITH
X.RDB$RELATION_NAME EQ relation_name->sym_string AND
X.RDB$FIELD_NAME EQ field_name->sym_string
rollback_update(relation->rel_database);
ERRQ_print_error(251, SafeArg() << field_name->sym_string <<
relation_name->sym_string);
// Msg251 Field %s already exists in relation %s
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
STUFF(isc_dyn_def_sql_fld);
STUFF_STRING(field->fld_name->sym_string);
STUFF(isc_dyn_fld_type);
STUFF_WORD(2);
STUFF_WORD(blr_dtypes[field->fld_dtype]);
STUFF(isc_dyn_fld_length);
STUFF_WORD(2);
const USHORT l = (field->fld_dtype == dtype_varying)
? field->fld_length - sizeof(SSHORT) : field->fld_length;
STUFF_WORD(l);
STUFF(isc_dyn_fld_scale);
STUFF_WORD(2);
STUFF_WORD(field->fld_scale);
if (DTYPE_IS_EXACT(field->fld_dtype))
{
STUFF(isc_dyn_fld_precision);
STUFF_WORD(2);
STUFF_WORD(field->fld_precision);
STUFF(isc_dyn_fld_sub_type);
STUFF_WORD(2);
STUFF_WORD(field->fld_sub_type);
}
if (position) {
STUFF(isc_dyn_fld_position);
STUFF_WORD(2);
STUFF_WORD(position);
}
rlb = CHECK_RLB(rlb);
if (field->fld_flags & FLD_not_null) {
STUFF(isc_dyn_fld_validation_blr);
STUFF_WORD(8);
STUFF(blr_version4);
STUFF(blr_not);
STUFF(blr_missing);
STUFF(blr_fid);
STUFF(0);
STUFF(0);
STUFF(0);
STUFF(blr_eoc);
}
STUFF(isc_dyn_end);
}
static void blob_copy( qli_rlb* rlb, qli_rel* source, ISC_QUAD& source_blob_id)
{
/**************************************
*
* b l o b _ c o p y
*
**************************************
*
* Functional description
* Copy information from one blob to a request
* language block to stick it into a new definition.
*
**************************************/
ISC_STATUS_ARRAY status_vector;
DBB source_dbb =
(source->rel_database) ? source->rel_database : QLI_databases;
DB = source_dbb->dbb_handle;
UserBlob source_blob(status_vector);
if (!source_blob.open(DB, source_dbb->dbb_meta_trans, source_blob_id))
{
rollback_update(source_dbb);
ERRQ_database_error(source_dbb, status_vector);
}
SLONG size, segment_count, max_segment;
if (!getBlobSize(source_blob, &size, &segment_count, &max_segment))
{
rollback_update(source_dbb);
ERRQ_database_error(source_dbb, status_vector);
}
TEXT fixed_buffer[4096];
TEXT* buffer;
USHORT buffer_length;
if (max_segment < static_cast<SLONG>(sizeof(fixed_buffer))) {
buffer_length = sizeof(fixed_buffer);
buffer = fixed_buffer;
}
else {
buffer_length = max_segment;
buffer = (TEXT *) gds__alloc((SLONG) buffer_length);
}
STUFF_WORD((USHORT) size);
size_t length;
while (source_blob.getSegment(buffer_length, buffer, length) && !source_blob.getCode())
{
while (rlb->rlb_data + length > rlb->rlb_limit)
rlb = GEN_rlb_extend(rlb);
const TEXT* p = buffer;
while (length--)
STUFF(*p++);
}
if (status_vector[1] != isc_segstr_eof) {
rollback_update(source_dbb);
if (buffer != fixed_buffer)
gds__free(buffer);
ERRQ_database_error(source_dbb, status_vector);
}
if (buffer != fixed_buffer)
gds__free(buffer);
if (!source_blob.close()) {
rollback_update(source_dbb);
ERRQ_database_error(source_dbb, status_vector);
}
//return TRUE;
}
static void change_field( qli_rel* relation, qli_fld* field)
{
/**************************************
*
* c h a n g e _ f i e l d
*
**************************************
*
* Functional description
* Change optional attributes of a field.
*
**************************************/
DBB database = relation->rel_database;
const qli_symbol* relation_name = relation->rel_symbol;
const qli_symbol* field_name = field->fld_name;
const qli_symbol* global_field = field->fld_based;
if (field->fld_dtype) {
rollback_update(database);
ERRQ_print_error(252);
// Msg252 datatype can not be changed locally
}
if (global_field
&&
!(check_global_field(database, NULL, global_field->sym_string)))
{
rollback_update(database);
ERRQ_print_error(253, global_field->sym_string);
// Msg253 global field %s does not exist
}
// Modify RFR
USHORT count = 0;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_mdf_rfr])
X IN DB.RDB$RELATION_FIELDS WITH
X.RDB$RELATION_NAME = relation_name->sym_string AND
X.RDB$FIELD_NAME = field_name->sym_string
count++;
MODIFY X USING
if (global_field)
strcpy(X.RDB$FIELD_SOURCE, global_field->sym_string);
const qli_symbol* symbol = field->fld_query_name;
if (symbol)
strcpy(X.RDB$QUERY_NAME, symbol->sym_string);
if (field->fld_edit_string)
strcpy(X.RDB$EDIT_STRING, field->fld_edit_string);
END_MODIFY
ON_ERROR
rollback_update(relation->rel_database);
ERRQ_database_error(relation->rel_database, gds_status);
END_ERROR;
END_FOR
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
if (!count) {
rollback_update(database);
ERRQ_print_error(254, SafeArg() << field_name->sym_string << relation_name->sym_string);
// Msg254 field %s not found in relation %s
}
}
static bool check_global_field(DBB database,
qli_fld* field,
const TEXT* name)
{
/**************************************
*
* c h e c k _ g l o b a l _ f i e l d
*
**************************************
*
* Functional description
* Given a name, check for the existence of a global field
* by that name. If a qli_fld block is supplied,
* check its characteristics against the global.
* If it is not fully defined, flesh it out from the global.
*
**************************************/
bool previously_defined = false;
FOR(REQUEST_HANDLE database->dbb_requests[REQ_field_def])
X IN DB.RDB$FIELDS WITH X.RDB$FIELD_NAME EQ name
if (field)
{
if (field->fld_dtype &&
(X.RDB$FIELD_TYPE != blr_dtypes[field->fld_dtype] ||
X.RDB$FIELD_LENGTH != static_cast<SLONG>(
((field->fld_dtype == dtype_varying) ? field->fld_length -
sizeof(SSHORT) : field->fld_length)) ||
X.RDB$FIELD_SCALE != field->fld_scale))
{
rollback_update(database);
ERRQ_print_error(255, name);
// Msg255 Datatype conflict with existing global field %s
}
field->fld_dtype = MET_get_datatype(X.RDB$FIELD_TYPE);
field->fld_length =
field_length(field->fld_dtype, X.RDB$FIELD_LENGTH);
if (field->fld_dtype == dtype_varying) {
field->fld_length += sizeof(SSHORT);
}
field->fld_scale = X.RDB$FIELD_SCALE;
field->fld_sub_type = X.RDB$FIELD_SUB_TYPE;
field->fld_sub_type_missing = X.RDB$FIELD_SUB_TYPE.NULL;
if (!field->fld_edit_string)
{
field->fld_edit_string =
make_string(X.RDB$EDIT_STRING, sizeof(X.RDB$EDIT_STRING));
}
if (!field->fld_query_name)
{
field->fld_query_name =
make_symbol(X.RDB$QUERY_NAME, sizeof(X.RDB$QUERY_NAME));
}
if (!field->fld_query_header)
{
ISC_QUAD& blob = X.RDB$QUERY_HEADER;
if (!UserBlob::blobIsNull(blob))
{
field->fld_query_header =
get_query_header(database, blob);
}
}
}
previously_defined = true;
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
return previously_defined;
}
static bool check_relation( qli_rel* relation)
{
/**************************************
*
* c h e c k _ r e l a t i o n
*
**************************************
*
* Functional description
* Check the existence of the named relation.
*
**************************************/
bool previously_defined = false;
FB_API_HANDLE spare = DB;
DB = relation->rel_database->dbb_handle;
FOR(REQUEST_HANDLE relation->rel_database->dbb_requests[REQ_relation_def]
TRANSACTION_HANDLE relation->rel_database->dbb_meta_trans)
X IN DB.RDB$RELATIONS WITH X.RDB$RELATION_NAME EQ relation->rel_symbol->sym_string
previously_defined = true;
END_FOR
ON_ERROR
ERRQ_database_error(relation->rel_database, gds_status);
END_ERROR;
DB = spare;
return previously_defined;
}
static void clone_fields( qli_rel* target, qli_rel* source)
{
/**************************************
*
* c l o n e _ f i e l d s
*
**************************************
*
* Functional description
* Copy the RFR records for one relation
* into another. The target database is already
* setup for updates. If there is a different source
* database, get it ready too. Then make sure that
* the source relation actually exists.
*
* If it's two different databases, create the global
* fields that are missing in the target (except those
* that support computed fields), then create the local
* fields and during that pass create the computed
* fields and the SQL fields.
*
**************************************/
FB_API_HANDLE req1, req2;
FB_API_HANDLE t_trans, s_trans;
req1 = req2 = 0;
s_trans = t_trans = gds_trans;
DB = DB1 = target->rel_database->dbb_handle;
if (target->rel_database != source->rel_database) {
MET_meta_transaction(source->rel_database, false);
s_trans = gds_trans;
}
if (target->rel_database != source->rel_database)
clone_global_fields(target, source);
qli_rlb* rlb = NULL;
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_begin);
FOR(REQUEST_HANDLE req1
TRANSACTION_HANDLE s_trans)
Y IN DB.RDB$RELATION_FIELDS
CROSS F IN DB.RDB$FIELDS
WITH Y.RDB$RELATION_NAME = source->rel_symbol->sym_string
AND Y.RDB$FIELD_SOURCE = F.RDB$FIELD_NAME
// If SQL made this field, create a new global field for it
if (F.RDB$COMPUTED_BLR.NULL &&
!fb_utils::implicit_domain(Y.RDB$FIELD_NAME) &&
fb_utils::implicit_domain(F.RDB$FIELD_NAME))
{
STUFF(isc_dyn_def_sql_fld);
STUFF_STRING(Y.RDB$FIELD_NAME);
STUFF(isc_dyn_fld_type);
STUFF_WORD(2);
STUFF_WORD(F.RDB$FIELD_TYPE);
STUFF(isc_dyn_fld_length);
STUFF_WORD(2);
STUFF_WORD(F.RDB$FIELD_LENGTH);
STUFF(isc_dyn_fld_scale);
STUFF_WORD(2);
STUFF_WORD(F.RDB$FIELD_SCALE);
if (!F.RDB$VALIDATION_BLR.NULL) {
STUFF(isc_dyn_fld_validation_blr);
blob_copy(rlb, source, F.RDB$VALIDATION_BLR);
}
}
else
{
STUFF(isc_dyn_def_local_fld);
STUFF_STRING(Y.RDB$FIELD_NAME);
STUFF(isc_dyn_fld_source);
STUFF_STRING(Y.RDB$FIELD_SOURCE);
}
STUFF(isc_dyn_rel_name);
STUFF_STRING(target->rel_symbol->sym_string);
if (!Y.RDB$FIELD_POSITION.NULL) {
STUFF(isc_dyn_fld_position);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$FIELD_POSITION);
}
if (!Y.RDB$QUERY_NAME.NULL) {
STUFF(isc_dyn_fld_query_name);
STUFF_STRING(Y.RDB$QUERY_NAME);
}
if (!Y.RDB$EDIT_STRING.NULL) {
STUFF(isc_dyn_fld_edit_string);
STUFF_STRING(Y.RDB$EDIT_STRING);
}
if (!Y.RDB$UPDATE_FLAG.NULL) {
STUFF(isc_dyn_update_flag);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$UPDATE_FLAG);
}
if (!Y.RDB$QUERY_HEADER.NULL) {
STUFF(isc_dyn_fld_query_header);
blob_copy(rlb, source, Y.RDB$QUERY_HEADER);
}
if (!Y.RDB$DESCRIPTION.NULL) {
STUFF(isc_dyn_description);
blob_copy(rlb, source, Y.RDB$DESCRIPTION);
}
if (!Y.RDB$DEFAULT_VALUE.NULL) {
STUFF(isc_dyn_fld_default_value);
blob_copy(rlb, source, Y.RDB$DEFAULT_VALUE);
}
if ((source->rel_database->dbb_capabilities & DBB_cap_rfr_sys_flag) &&
(target->rel_database->dbb_capabilities & DBB_cap_rfr_sys_flag))
FOR(REQUEST_HANDLE req2
TRANSACTION_HANDLE s_trans)
S_RFR IN DB.RDB$RELATION_FIELDS WITH
S_RFR.RDB$FIELD_NAME = Y.RDB$FIELD_NAME AND
S_RFR.RDB$RELATION_NAME = Y.RDB$RELATION_NAME
if (!S_RFR.RDB$SYSTEM_FLAG.NULL) {
STUFF(isc_dyn_system_flag);
STUFF_WORD(2);
STUFF_WORD(S_RFR.RDB$SYSTEM_FLAG);
}
END_FOR
ON_ERROR
rollback_update(target->rel_database);
ERRQ_database_error(source->rel_database, gds_status);
END_ERROR;
if (!F.RDB$COMPUTED_BLR.NULL)
{
STUFF(isc_dyn_fld_computed_blr);
blob_copy(rlb, source, F.RDB$COMPUTED_BLR);
STUFF(isc_dyn_fld_computed_source);
blob_copy(rlb, source, F.RDB$COMPUTED_SOURCE);
STUFF(isc_dyn_fld_type);
STUFF_WORD(2);
STUFF_WORD(F.RDB$FIELD_TYPE);
STUFF(isc_dyn_fld_length);
STUFF_WORD(2);
STUFF_WORD(F.RDB$FIELD_LENGTH);
if (!F.RDB$FIELD_SCALE.NULL) {
STUFF(isc_dyn_fld_scale);
STUFF_WORD(2);
STUFF_WORD(F.RDB$FIELD_SCALE);
}
if (!F.RDB$FIELD_SUB_TYPE.NULL) {
STUFF(isc_dyn_fld_sub_type);
STUFF_WORD(2);
STUFF_WORD(F.RDB$FIELD_SUB_TYPE);
}
}
STUFF(isc_dyn_end);
END_FOR
ON_ERROR
rollback_update(source->rel_database);
ERRQ_database_error(source->rel_database, gds_status);
END_ERROR;
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
execute_dynamic_ddl(target->rel_database, rlb);
if (req1)
if (isc_release_request(gds_status, &req1))
ERRQ_database_error(source->rel_database, gds_status);
if (req2)
if (isc_release_request(gds_status, &req2))
ERRQ_database_error(source->rel_database, gds_status);
//return TRUE;
}
static void clone_global_fields( qli_rel* target, qli_rel* source)
{
/**************************************
*
* c l o n e _ g l o b a l _ f i e l d s
*
**************************************
*
* Functional description
* Copy the global field definitions required by a relation
* from one database into another. Both databases are
* setup correctly. (Set up the handles again just because
* we're compulsive.)
*
* In this routine, as in clone fields, be careful to probe
* for our extensions rather than just using them so we
* can copy relations from V2 and from Rdb.
*
* Don't clone fields that already exist and have the
* correct datatype and length.
*
* Don't clone computed fields since they will be cloned
* later with the local field definitions. Don't clone
* SQL defined fields for the same reason.
*
**************************************/
FB_API_HANDLE req1, req2, req3;
req1 = req2 = req3 = 0;
FB_API_HANDLE s_trans = source->rel_database->dbb_meta_trans;
FB_API_HANDLE t_trans = target->rel_database->dbb_meta_trans;
DB = source->rel_database->dbb_handle;
DB1 = target->rel_database->dbb_handle;
qli_rlb* rlb = NULL;
bool first_field = true;
FOR(REQUEST_HANDLE req1
TRANSACTION_HANDLE s_trans)
RFR IN DB.RDB$RELATION_FIELDS CROSS
Y IN DB.RDB$FIELDS
WITH RFR.RDB$RELATION_NAME = source->rel_symbol->sym_string AND
Y.RDB$FIELD_NAME = RFR.RDB$FIELD_SOURCE REDUCED TO Y.RDB$FIELD_NAME
if (!Y.RDB$COMPUTED_BLR.NULL ||
(!fb_utils::implicit_domain(RFR.RDB$FIELD_NAME) &&
fb_utils::implicit_domain(Y.RDB$FIELD_NAME)))
{
continue;
}
bool predefined = false;
FOR(REQUEST_HANDLE req2 TRANSACTION_HANDLE t_trans)
A IN DB1.RDB$FIELDS WITH A.RDB$FIELD_NAME = Y.RDB$FIELD_NAME
if ((A.RDB$FIELD_TYPE != Y.RDB$FIELD_TYPE) ||
(A.RDB$FIELD_LENGTH != Y.RDB$FIELD_LENGTH) ||
(A.RDB$FIELD_SCALE.NULL != Y.RDB$FIELD_SCALE.NULL) ||
((!Y.RDB$FIELD_SCALE.NULL) &&
(A.RDB$FIELD_SCALE != Y.RDB$FIELD_SCALE)) ||
(A.RDB$FIELD_SUB_TYPE.NULL != Y.RDB$FIELD_SUB_TYPE.NULL)
|| ((!Y.RDB$FIELD_SUB_TYPE.NULL)
&& (A.RDB$FIELD_SUB_TYPE != Y.RDB$FIELD_SUB_TYPE)))
{
TEXT* name = (TEXT*) ALLQ_malloc((SLONG) sizeof(Y.RDB$FIELD_NAME));
strcpy(name, Y.RDB$FIELD_NAME);
rollback_update(target->rel_database);
// CVC: When is this memory deallocated?
ERRQ_error(413, name);
// conflicting previous definition
}
else
predefined = true;
END_FOR
ON_ERROR
ERRQ_database_error(target->rel_database, gds_status);
END_ERROR;
if (predefined)
continue;
if (first_field) {
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_begin);
first_field = false;
}
STUFF(isc_dyn_def_global_fld);
STUFF_STRING(Y.RDB$FIELD_NAME);
STUFF(isc_dyn_fld_type);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$FIELD_TYPE);
STUFF(isc_dyn_fld_length);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$FIELD_LENGTH);
if (!Y.RDB$FIELD_SCALE.NULL) {
STUFF(isc_dyn_fld_scale);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$FIELD_SCALE);
}
if (!Y.RDB$FIELD_SUB_TYPE.NULL) {
STUFF(isc_dyn_fld_sub_type);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$FIELD_SUB_TYPE);
}
if (!Y.RDB$SEGMENT_LENGTH.NULL) {
STUFF(isc_dyn_fld_segment_length);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$SEGMENT_LENGTH);
}
if (!Y.RDB$SYSTEM_FLAG.NULL) {
STUFF(isc_dyn_system_flag);
STUFF_WORD(2);
STUFF_WORD(Y.RDB$SYSTEM_FLAG);
}
if (!Y.RDB$QUERY_NAME.NULL) {
STUFF(isc_dyn_fld_query_name);
STUFF_STRING(Y.RDB$QUERY_NAME);
}
if (!Y.RDB$EDIT_STRING.NULL) {
STUFF(isc_dyn_fld_edit_string);
STUFF_STRING(Y.RDB$EDIT_STRING);
}
if (!Y.RDB$MISSING_VALUE.NULL) {
STUFF(isc_dyn_fld_missing_value);
blob_copy(rlb, source, Y.RDB$MISSING_VALUE);
}
if (!Y.RDB$DEFAULT_VALUE.NULL) {
STUFF(isc_dyn_fld_default_value);
blob_copy(rlb, source, Y.RDB$DEFAULT_VALUE);
}
if (!Y.RDB$QUERY_HEADER.NULL) {
STUFF(isc_dyn_fld_query_header);
blob_copy(rlb, source, Y.RDB$QUERY_HEADER);
}
if (!Y.RDB$DESCRIPTION.NULL) {
STUFF(isc_dyn_description);
blob_copy(rlb, source, Y.RDB$DESCRIPTION);
}
if (!Y.RDB$VALIDATION_BLR.NULL) {
STUFF(isc_dyn_fld_validation_blr);
blob_copy(rlb, source, Y.RDB$VALIDATION_BLR);
}
if (!Y.RDB$VALIDATION_SOURCE.NULL) {
STUFF(isc_dyn_fld_validation_source);
blob_copy(rlb, source, Y.RDB$VALIDATION_SOURCE);
}
if ((target->rel_database->dbb_capabilities & DBB_cap_dimensions) &&
(source->rel_database->dbb_capabilities & DBB_cap_dimensions))
{
bool first_dimension = true;
FOR(REQUEST_HANDLE req3 TRANSACTION_HANDLE s_trans)
F IN DB.RDB$FIELDS CROSS
D IN DB.RDB$FIELD_DIMENSIONS
WITH F.RDB$FIELD_NAME = D.RDB$FIELD_NAME AND
F.RDB$FIELD_NAME = Y.RDB$FIELD_NAME
if (first_dimension) {
first_dimension = false;
STUFF(isc_dyn_fld_dimensions);
STUFF_WORD(2);
STUFF_WORD(F.RDB$DIMENSIONS);
}
STUFF(isc_dyn_def_dimension);
STUFF_WORD(2);
STUFF_WORD(D.RDB$DIMENSION);
if (!D.RDB$LOWER_BOUND.NULL) {
STUFF(isc_dyn_dim_lower);
STUFF_WORD(2);
STUFF_WORD(D.RDB$LOWER_BOUND);
}
if (!D.RDB$UPPER_BOUND.NULL) {
STUFF(isc_dyn_dim_upper);
STUFF_WORD(2);
STUFF_WORD(D.RDB$UPPER_BOUND);
}
STUFF(isc_dyn_end);
END_FOR
ON_ERROR
if (target->rel_database->dbb_meta_trans)
rollback_update(target->rel_database);
rollback_update(source->rel_database);
ERRQ_database_error(source->rel_database, gds_status);
END_ERROR;
}
STUFF(isc_dyn_end);
END_FOR
ON_ERROR
rollback_update(source->rel_database);
if (target->rel_database->dbb_meta_trans)
rollback_update(target->rel_database);
ERRQ_database_error(source->rel_database, gds_status);
END_ERROR;
if (rlb) {
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
execute_dynamic_ddl(target->rel_database, rlb);
}
if (req1)
if (isc_release_request(gds_status, &req1))
ERRQ_database_error(source->rel_database, gds_status);
if (req2)
if (isc_release_request(gds_status, &req2))
ERRQ_database_error(target->rel_database, gds_status);
if (req3)
if (isc_release_request(gds_status, &req3))
ERRQ_database_error(source->rel_database, gds_status);
//return TRUE;
}
static void define_global_field( DBB database, qli_fld* field, qli_symbol* name)
{
/**************************************
*
* d e f i n e _ g l o b a l _ f i e l d
*
**************************************
*
* Functional description
*
* Define a global field if we've got enough
* information.
*
**************************************/
if (!field->fld_dtype) {
rollback_update(database);
ERRQ_print_error(256, name->sym_string); // Msg256 No datatype specified for field %s
}
STORE(REQUEST_HANDLE database->dbb_requests[REQ_store_field])
X IN DB.RDB$FIELDS
strcpy(X.RDB$FIELD_NAME, name->sym_string);
X.RDB$FIELD_TYPE = blr_dtypes[field->fld_dtype];
X.RDB$FIELD_SCALE = field->fld_scale;
X.RDB$FIELD_LENGTH = (field->fld_dtype == dtype_varying) ?
field->fld_length - sizeof(SSHORT) : field->fld_length;
if (!field->fld_sub_type_missing) {
X.RDB$FIELD_SUB_TYPE.NULL = FALSE;
X.RDB$FIELD_SUB_TYPE = field->fld_sub_type;
}
else
X.RDB$FIELD_SUB_TYPE.NULL = TRUE;
const qli_symbol* symbol = field->fld_query_name;
if (symbol) {
X.RDB$QUERY_NAME.NULL = FALSE;
strcpy(X.RDB$QUERY_NAME, symbol->sym_string);
}
else
X.RDB$QUERY_NAME.NULL = TRUE;
if (field->fld_edit_string) {
X.RDB$EDIT_STRING.NULL = FALSE;
strcpy(X.RDB$EDIT_STRING, field->fld_edit_string);
}
else
X.RDB$EDIT_STRING.NULL = TRUE;
END_STORE
ON_ERROR
rollback_update(database);
ERRQ_database_error(database, gds_status);
END_ERROR;
}
static void delete_fields( qli_rel* relation)
{
/**************************************
*
* d e l e t e _ f i e l d s
*
**************************************
*
* Functional description
* Delete field definitions.
*
**************************************/
while (qli_fld* field = relation->rel_fields) {
relation->rel_fields = field->fld_next;
ALLQ_release((FRB) field->fld_name);
if (field->fld_query_name)
ALLQ_release((FRB) field->fld_query_name);
ALLQ_release((FRB) field);
}
relation->rel_flags &= ~REL_fields;
}
static ISC_STATUS detach(ISC_STATUS * status_vector,
DBB dbb)
{
/**************************************
*
* d e t a c h
*
**************************************
*
* Functional description
* Shut down a database. Return the status of the
* first failing call, if any.
*
**************************************/
if (!dbb->dbb_handle)
return FB_SUCCESS;
ISC_STATUS_ARRAY alt_vector;
ISC_STATUS* status = status_vector;
if (dbb->dbb_transaction)
if (isc_commit_transaction(status, &dbb->dbb_transaction))
status = alt_vector;
if (dbb->dbb_proc_trans && (dbb->dbb_capabilities & DBB_cap_multi_trans))
if (isc_commit_transaction(status, &dbb->dbb_proc_trans))
status = alt_vector;
if (dbb->dbb_meta_trans && (dbb->dbb_capabilities & DBB_cap_multi_trans))
if (isc_commit_transaction(status, &dbb->dbb_meta_trans))
status = alt_vector;
isc_detach_database(status, &dbb->dbb_handle);
return status_vector[1];
}
static void execute_dynamic_ddl( DBB database, qli_rlb* rlb)
{
/**************************************
*
* e x e c u t e _ d y n a m i c _ d d l
*
**************************************
*
* Functional description
* Execute a ddl command, for better or for worse.
*
**************************************/
const USHORT length = (UCHAR *) rlb->rlb_data - (UCHAR *) rlb->rlb_base;
if (QLI_blr)
PRETTY_print_dyn(rlb->rlb_base, NULL, NULL, 0);
if (isc_ddl(gds_status, &database->dbb_handle, &database->dbb_meta_trans,
length, (const char*) rlb->rlb_base))
{
rollback_update(database);
ERRQ_database_error(database, gds_status);
}
GEN_rlb_release (rlb);
}
static int field_length( USHORT dtype, USHORT length)
{
/**************************************
*
* f i e l d _ l e n g t h
*
**************************************
*
* Functional description
* Return implementation specific length for field.
*
**************************************/
switch (dtype) {
case dtype_short:
return sizeof(SSHORT);
case dtype_long:
return sizeof(SLONG);
case dtype_real:
return sizeof(float);
case dtype_double:
return sizeof(double);
case dtype_int64:
return sizeof(SINT64);
case dtype_sql_time:
case dtype_sql_date:
return sizeof(SLONG);
case dtype_timestamp:
case dtype_blob:
case dtype_quad:
return sizeof(ISC_QUAD);
}
return length;
}
static void get_database_type( DBB new_dbb)
{
/**************************************
*
* g e t _ d a t a b a s e _ t y p e
*
**************************************
*
* Functional description
* Ask what type of database this is.
*
**************************************/
ISC_STATUS_ARRAY status_vector;
UCHAR buffer[1024];
isc_database_info(status_vector, &new_dbb->dbb_handle, sizeof(db_info),
reinterpret_cast<const char*>(db_info),
sizeof(buffer), (char*) buffer);
if (status_vector[1])
ERRQ_database_error(new_dbb, gds_status);
UCHAR* p = buffer;
while (*p != isc_info_end && p < buffer + sizeof(buffer)) {
UCHAR item = *p++;
USHORT l = gds__vax_integer(p, 2);
p += 2;
switch (item) {
case isc_info_implementation:
{
const UCHAR* q = p;
int count = *q++;
while (count--) {
new_dbb->dbb_type = *q++;
if (*q++ == isc_info_db_class_access)
break;
}
break;
}
default:
ERRQ_error(257);
// Msg257 database info call failed
}
p += l;
}
}
static TEXT *get_query_header( DBB database, ISC_QUAD& blob_id)
{
/**************************************
*
* g e t _ q u e r y _ h e a d e r
*
**************************************
*
* Functional description
* Pick up a query header for a field.
*
**************************************/
ISC_STATUS_ARRAY status_vector;
TEXT header[1024], buffer[1024];
UserBlob blob(status_vector);
if (!blob.open(database->dbb_handle, gds_trans, blob_id))
{
ERRQ_database_error(database, status_vector);
}
TEXT* p = header;
// CVC: No bounds check here: it's assumed that 1024 is enough, but "p"
// might overflow "header" eventually.
for (;;) {
size_t length;
if (!blob.getSegment(sizeof(buffer), buffer, length))
break;
if (length && buffer[length - 1] == '\n')
--length;
buffer[length] = 0;
const TEXT* q = buffer;
if (*q == '"')
do {
*p++ = *q++;
} while (*q);
else {
*p++ = '"';
while (*q)
*p++ = *q++;
*p++ = '"';
}
}
if (!blob.close())
ERRQ_database_error(database, gds_status);
*p = 0;
if (!strcmp(header, "\" \"")) {
header[0] = '-';
header[1] = 0;
p = header + 1;
}
const USHORT len = p - header;
if (len)
return make_string(header, len);
return NULL;
}
static void install( dbb* old_dbb)
{
/**************************************
*
* i n s t a l l
*
**************************************
*
* Functional description
* Install a database. Scan relations, etc., make up relation
* blocks, etc, and copy the database block to someplace more
* permanent.
*
**************************************/
// Copy the database block to one out of the permanent pool
SSHORT l = old_dbb->dbb_filename_length;
DBB new_dbb = (DBB) ALLOCPV(type_dbb, l);
new_dbb->dbb_filename_length = l;
memcpy(new_dbb->dbb_filename, old_dbb->dbb_filename, l);
DB = new_dbb->dbb_handle = old_dbb->dbb_handle;
new_dbb->dbb_capabilities = old_dbb->dbb_capabilities;
new_dbb->dbb_next = QLI_databases;
QLI_databases = new_dbb;
// If a name was given, make up a symbol for the database.
nam* name = (nam*) old_dbb->dbb_symbol;
if (name) {
qli_symbol* asymbol = make_symbol(name->nam_string, name->nam_length);
new_dbb->dbb_symbol = asymbol;
asymbol->sym_type = SYM_database;
asymbol->sym_object = (BLK) new_dbb;
HSH_insert(asymbol, true);
}
gds_trans = MET_transaction(nod_start_trans, new_dbb);
/* Find out whose database this is so later we don't ask Rdb/VMS
or its pals to do any unnatural acts. While we're at it get
general capabilities */
get_database_type(new_dbb);
set_capabilities(new_dbb);
/* Get all relations in database. For each relation make up a
relation block, make up a symbol block, and insert the symbol
into the hash table. */
FB_API_HANDLE request = 0;
FOR(REQUEST_HANDLE request) X IN DB.RDB$RELATIONS
SORTED BY DESCENDING X.RDB$RELATION_NAME
qli_rel* relation = (qli_rel*) ALLOCP(type_rel);
relation->rel_next = new_dbb->dbb_relations;
new_dbb->dbb_relations = relation;
relation->rel_database = new_dbb;
relation->rel_id = X.RDB$RELATION_ID;
qli_symbol* rsymbol = make_symbol(X.RDB$RELATION_NAME, sizeof(X.RDB$RELATION_NAME));
rsymbol->sym_type = SYM_relation;
rsymbol->sym_object = (BLK) relation;
relation->rel_symbol = rsymbol;
HSH_insert(rsymbol);
if (strcmp(rsymbol->sym_string, "QLI$PROCEDURES") == 0)
new_dbb->dbb_flags |= DBB_procedures;
if (relation->rel_system_flag = X.RDB$SYSTEM_FLAG)
relation->rel_flags |= REL_system;
if (!X.RDB$VIEW_BLR.NULL)
relation->rel_flags |= REL_view;
END_FOR
ON_ERROR
ERRQ_database_error(new_dbb, gds_status);
END_ERROR;
if (request)
if (isc_release_request(gds_status, &request))
ERRQ_database_error(new_dbb, gds_status);
// Pick up functions, if appropriate
if (new_dbb->dbb_capabilities & DBB_cap_functions) {
FB_API_HANDLE request2 = 0;
FOR(REQUEST_HANDLE request) X IN DB.RDB$FUNCTIONS
qli_symbol* fsymbol = make_symbol(X.RDB$FUNCTION_NAME, sizeof(X.RDB$FUNCTION_NAME));
if (!fsymbol)
continue;
qli_fun* function = (qli_fun*) ALLOCPV(type_fun, 0);
function->fun_next = new_dbb->dbb_functions;
new_dbb->dbb_functions = function;
function->fun_symbol = fsymbol;
function->fun_database = new_dbb;
FOR(REQUEST_HANDLE request2) Y IN DB.RDB$FUNCTION_ARGUMENTS WITH
Y.RDB$FUNCTION_NAME EQ X.RDB$FUNCTION_NAME AND
Y.RDB$ARGUMENT_POSITION EQ X.RDB$RETURN_ARGUMENT
function->fun_return.dsc_dtype = MET_get_datatype(Y.RDB$FIELD_TYPE);
function->fun_return.dsc_length =
field_length(function->fun_return.dsc_dtype,
Y.RDB$FIELD_LENGTH);
function->fun_return.dsc_scale = Y.RDB$FIELD_SCALE;
END_FOR
ON_ERROR
ERRQ_database_error(new_dbb, gds_status);
END_ERROR;
if (!function->fun_return.dsc_dtype) {
function->fun_return.dsc_dtype = dtype_text;
function->fun_return.dsc_length = 20;
}
fsymbol->sym_type = SYM_function;
fsymbol->sym_object = (BLK) function;
HSH_insert(fsymbol);
// Insert another symbol if there is a function query name
qli_symbol* symbol2 = make_symbol(X.RDB$QUERY_NAME, sizeof(X.RDB$QUERY_NAME));
if (symbol2) {
function->fun_query_name = symbol2;
symbol2->sym_type = SYM_function;
symbol2->sym_object = (BLK) function;
HSH_insert(symbol2, true);
}
END_FOR
ON_ERROR
ERRQ_database_error(new_dbb, gds_status);
END_ERROR;
if (request)
if (isc_release_request(gds_status, &request))
ERRQ_database_error(new_dbb, gds_status);
if (request2)
if (isc_release_request(gds_status, &request2))
ERRQ_database_error(new_dbb, gds_status);
}
}
static qli_syntax* make_node( NOD_T type, USHORT count)
{
/**************************************
*
* m a k e _ n o d e
*
**************************************
*
* Functional description
* Generate a syntax node.
*
**************************************/
qli_syntax* node = (qli_syntax*) ALLOCPV(type_syn, count);
node->syn_count = count;
node->syn_type = type;
return node;
}
static TEXT *make_string( TEXT* string, SSHORT length)
{
/**************************************
*
* m a k e _ s t r i n g
*
**************************************
*
* Functional description
* Make up a permanent string from a large string. Chop off
* trailing blanks. If there's nothing left, return NULL.
*
**************************************/
string[length] = 0;
if (!(length = truncate_string(string)))
return NULL;
qli_str* str = (qli_str*) ALLOCPV(type_str, length + 1);
TEXT* p = str->str_data;
do {
*p++ = *string++;
} while (--length);
*p = 0;
return str->str_data;
}
static qli_symbol* make_symbol( TEXT* string, SSHORT length)
{
/**************************************
*
* m a k e _ s y m b o l
*
**************************************
*
* Functional description
* Make up a symbol from a string. If the string is all blanks,
* don't make up a symbol. Phooey.
*
**************************************/
if (!(length = truncate_string(string)))
return NULL;
qli_symbol* symbol = (qli_symbol*) ALLOCPV(type_sym, length);
symbol->sym_type = SYM_relation;
symbol->sym_length = length;
TEXT* p = symbol->sym_name;
symbol->sym_string = p;
do {
*p++ = *string++;
} while (--length);
return symbol;
}
static qli_const* missing_value( ISC_QUAD& blob_id, qli_symbol* symbol)
{
/**************************************
*
* m i s s i n g _ v a l u e
*
**************************************
*
* Functional description
* Get a missing value into a constant
* block for later reference.
*
**************************************/
qli_syntax* element = parse_blr_blob(blob_id, symbol);
if (element)
return ((qli_const*) element->syn_arg[0]);
else
return NULL;
}
static qli_syntax* parse_blr( UCHAR ** ptr, qli_symbol* symbol)
{
/**************************************
*
* p a r s e _ b l r
*
**************************************
*
* Functional description
* Parse a BLR expression.
*
**************************************/
qli_syntax* *arg;
qli_const* constant;
NOD_T operatr;
NAM name;
UCHAR *p;
SSHORT dtype, scale, length, l, op;
UCHAR* blr = *ptr;
SSHORT args = 2;
qli_syntax* node = NULL;
switch (op = BLR_BYTE) {
case blr_any:
case blr_unique:
case blr_eoc:
return NULL;
case blr_eql:
operatr = nod_eql;
break;
case blr_neq:
operatr = nod_neq;
break;
case blr_gtr:
operatr = nod_gtr;
break;
case blr_geq:
operatr = nod_geq;
break;
case blr_lss:
operatr = nod_lss;
break;
case blr_leq:
operatr = nod_leq;
break;
case blr_containing:
operatr = nod_containing;
break;
case blr_starting:
operatr = nod_starts;
break;
case blr_matching:
operatr = nod_matches;
break;
case blr_matching2:
operatr = nod_sleuth;
break;
case blr_like:
operatr = nod_like;
break;
case blr_and:
operatr = nod_and;
break;
case blr_or:
operatr = nod_or;
break;
case blr_add:
operatr = nod_add;
break;
case blr_subtract:
operatr = nod_subtract;
break;
case blr_multiply:
operatr = nod_multiply;
break;
case blr_divide:
operatr = nod_divide;
break;
case blr_upcase:
operatr = nod_upcase;
break;
case blr_lowcase:
operatr = nod_lowcase;
break;
case blr_null:
operatr = nod_null;
break;
case blr_between:
operatr = nod_between;
args = 3;
break;
case blr_not:
operatr = nod_not;
args = 1;
break;
case blr_negate:
operatr = nod_negate;
args = 1;
break;
case blr_missing:
operatr = nod_missing;
args = 1;
break;
case blr_fid:
BLR_BYTE;
blr += 2;
node = make_node(nod_field, 1);
name = (NAM) ALLOCPV(type_nam, symbol->sym_length);
node->syn_arg[0] = (qli_syntax*) name;
name->nam_length = symbol->sym_length;
strcpy(name->nam_string, symbol->sym_string);
break;
case blr_field:
BLR_BYTE;
length = BLR_BYTE;
node = make_node(nod_field, 1);
name = (NAM) ALLOCPV(type_nam, length);
node->syn_arg[0] = (qli_syntax*) name;
name->nam_length = length;
p = (UCHAR *) name->nam_string;
do {
*p++ = BLR_BYTE;
} while (--length);
break;
case blr_function:
length = BLR_BYTE;
node = make_node(nod_function, s_fun_count);
node->syn_arg[s_fun_function] = (qli_syntax*) HSH_lookup((SCHAR*) blr, length);
blr += length;
args = BLR_BYTE;
node->syn_arg[s_fun_args] = make_node(nod_list, args);
arg = node->syn_arg[s_fun_args]->syn_arg;
while (--args >= 0) {
if (!(*arg++ = parse_blr(&blr, symbol)))
return NULL;
}
break;
case blr_literal:
scale = 0;
switch (BLR_BYTE) {
case blr_text:
dtype = dtype_text;
length = l = gds__vax_integer(blr, 2);
blr += 2;
break;
case blr_text2:
dtype = dtype_text;
scale = gds__vax_integer(blr, 2);
blr += 2;
length = l = gds__vax_integer(blr, 2);
blr += 2;
break;
case blr_varying:
dtype = dtype_varying;
length = l = gds__vax_integer(blr, 2) + sizeof(USHORT);
blr += 2;
break;
case blr_varying2:
dtype = dtype_varying;
scale = gds__vax_integer(blr, 2);
blr += 2;
length = l = gds__vax_integer(blr, 2) + sizeof(USHORT);
blr += 2;
break;
case blr_short:
dtype = dtype_short;
l = 2;
length = sizeof(SSHORT);
scale = (int) BLR_BYTE;
break;
case blr_long:
dtype = dtype_long;
length = sizeof(SLONG);
l = 4;
scale = (int) BLR_BYTE;
break;
case blr_quad:
dtype = dtype_quad;
l = 8;
length = sizeof(ISC_QUAD);
scale = (int) BLR_BYTE;
break;
case blr_int64:
dtype = dtype_int64;
l = 8;
length = sizeof(SINT64);
scale = (int) BLR_BYTE;
break;
case blr_timestamp:
dtype = dtype_timestamp;
l = 8;
length = sizeof(ISC_QUAD);
break;
case blr_sql_date:
dtype = dtype_sql_date;
l = 4;
length = sizeof(SLONG);
break;
case blr_sql_time:
dtype = dtype_sql_time;
l = 4;
length = sizeof(ULONG);
break;
}
constant = (qli_const*) ALLOCPV(type_con, length);
constant->con_desc.dsc_dtype = dtype;
constant->con_desc.dsc_scale = scale;
constant->con_desc.dsc_length = length;
constant->con_desc.dsc_address = p = constant->con_data;
if (dtype == dtype_text)
while (l--)
*p++ = BLR_BYTE;
else if (dtype == dtype_short) {
*(SSHORT *) p = gds__vax_integer(blr, l);
blr += l;
}
else if (dtype == dtype_long) {
*(SLONG *) p = gds__vax_integer(blr, l);
blr += l;
}
node = make_node(nod_constant, 1);
node->syn_count = 0;
node->syn_arg[0] = (qli_syntax*) constant;
break;
default:
ERRQ_print_error(258, SafeArg() << op); // Msg258 don't understand BLR operatr %d
}
if (!node) {
node = make_node(operatr, args);
arg = node->syn_arg;
while (--args >= 0)
if (!(*arg++ = parse_blr(&blr, symbol)))
return NULL;
}
*ptr = blr;
return node;
}
static qli_syntax* parse_blr_blob(ISC_QUAD& blob_id, qli_symbol* symbol)
{
/**************************************
*
* p a r s e _ b l r _ b l o b
*
**************************************
*
* Functional description
* Gobble up a BLR blob, if possible.
*
**************************************/
ISC_STATUS_ARRAY status_vector;
if (UserBlob::blobIsNull(blob_id))
return NULL;
UserBlob handle(status_vector);
if (!handle.open(DB, gds_trans, blob_id))
return NULL;
UCHAR buffer[1024];
UCHAR* ptr = buffer;
for (;;) {
size_t length = buffer + sizeof(buffer) - ptr;
if (!length)
break;
// The old code considered getting a portion of a segment a bug.
// Anyway, 1024 is not much to contain the BLR stream, even for validation.
if (!handle.getSegment(length, ptr, length) || handle.getCode())
break;
ptr += length;
}
if (!handle.close())
return NULL;
if (ptr == buffer)
return NULL;
ptr = buffer;
if (*ptr++ != blr_version4)
return NULL;
qli_syntax* node = parse_blr(&ptr, symbol);
if (*ptr != blr_eoc)
return NULL;
return node;
}
static void purge_relation(qli_rel* relation)
{
/**************************************
*
* p u r g e _ r e l a t i o n
*
**************************************
*
* Functional description
* Purge a relation out of internal data structures.
*
**************************************/
qli_symbol* symbol = relation->rel_symbol;
DBB database = relation->rel_database;
HSH_remove(symbol);
for (qli_rel** ptr = &database->dbb_relations; *ptr; ptr = &(*ptr)->rel_next)
{
if (*ptr == relation) {
*ptr = relation->rel_next;
break;
}
}
qli_fld* field;
while (field = relation->rel_fields) {
relation->rel_fields = field->fld_next;
ALLQ_release((FRB) field->fld_name);
if (symbol = field->fld_query_name) {
ALLQ_release((FRB) symbol);
}
ALLQ_release((FRB) field);
}
ALLQ_release((FRB) relation);
}
static void put_dyn_string( qli_rlb* rlb, const TEXT* string)
{
/**************************************
*
* p u t _ d y n _ s t r i n g
*
**************************************
*
* Functional description
* Move a string to a dynamic DDL command block.
*
**************************************/
const SSHORT l = strlen(string);
while ((SSHORT) (rlb->rlb_limit - rlb->rlb_data) < l) {
rlb = GEN_rlb_extend(rlb);
}
STUFF_WORD(l);
while (*string) {
STUFF(*string++);
}
CHECK_RLB(rlb);
}
static void rollback_update( DBB database)
{
/**************************************
*
* r o l l b a c k _ u p d a t e
*
**************************************
*
* Functional description
* Roll back a meta-data update.
*
**************************************/
if (gds_trans == database->dbb_meta_trans &&
(database->dbb_capabilities & DBB_cap_multi_trans))
{
ISC_STATUS_ARRAY alt_vector;
isc_rollback_transaction(alt_vector, &database->dbb_meta_trans);
// Note: No message given if rollback fails
}
gds_trans = 0;
}
static void set_capabilities( DBB database)
{
/**************************************
*
* s e t _ c a p a b i l i t i e s
*
**************************************
*
* Functional description
* Probe the database to determine
* what metadata capabilities it has.
* The table, rfr_table, in the static
* data declarations has the relation
* and field names, together with the
* capabilities bits.
*
**************************************/
FB_API_HANDLE req = 0;
// Look for desireable fields in system relations
for (const rfr_tab_t* rel_field_table = rfr_table; rel_field_table->relation;
rel_field_table++)
{
FOR(REQUEST_HANDLE req) x IN DB.RDB$RELATION_FIELDS
WITH x.RDB$RELATION_NAME = rel_field_table->relation
AND x.RDB$FIELD_NAME = rel_field_table->field
database->dbb_capabilities |= rel_field_table->bit_mask;
END_FOR
ON_ERROR
ERRQ_database_error(database, gds_status);
END_ERROR;
}
if (req)
{
if (isc_release_request(gds_status, &req))
ERRQ_database_error(database, gds_status);
}
}
static DBB setup_update( DBB database)
{
/**************************************
*
* s e t u p _ u p d a t e
*
**************************************
*
* Functional description
* Get ready to do a meta data update.
* If no database was specified, use the
* most recently readied one.
*
**************************************/
if (!database)
database = QLI_databases;
MET_meta_transaction(database, true);
return database;
}
static void sql_grant_revoke( qli_syntax* node, USHORT type)
{
/*****************************************************
*
* s q l _ g r a n t _ r e v o k e
*
*****************************************************
*
* Build a DYN string for a SQL GRANT or REVOKE statement
*
*****************************************************/
const USHORT privileges = (IPTR) node->syn_arg[s_grant_privileges];
qli_rel* relation = (qli_rel*) node->syn_arg[s_grant_relation];
DBB database = setup_update(relation->rel_database);
relation->rel_database = database;
const TEXT* relation_name = relation->rel_symbol->sym_string;
qli_rlb* rlb = NULL;
rlb = CHECK_RLB(rlb);
STUFF(isc_dyn_version_1);
STUFF(isc_dyn_begin);
// For each user create a separate grant string
// For each specified field create a separate grant string
qli_syntax* names = node->syn_arg[s_grant_users];
qli_syntax* fields = node->syn_arg[s_grant_fields];
NAM* name = (NAM*) names->syn_arg;
for (NAM* const end = name + names->syn_count;
name < end; name++)
{
if (fields->syn_count) {
NAM* field = (NAM *) fields->syn_arg;
NAM* const end_field = field + fields->syn_count;
for (; field < end_field; field++)
{
stuff_priv(rlb, type, relation_name, privileges,
(*name)->nam_string, (*field)->nam_string);
}
}
else
stuff_priv(rlb, type, relation_name, privileges,
(*name)->nam_string, NULL);
}
STUFF(isc_dyn_end);
STUFF(isc_dyn_eoc);
execute_dynamic_ddl(database, rlb);
MET_meta_commit(database);
}
static int truncate_string( TEXT* string)
{
/**************************************
*
* t r u n c a t e _ s t r i n g
*
**************************************
*
* Functional description
* Convert a blank filled string to
* a null terminated string without
* trailing blanks. Because some
* strings contain embedded blanks
* (e.g. query headers & edit strings)
* truncate from the back forward.
* Return the number of characters found,
* not including the terminating null.
*
**************************************/
const int len = fb_utils::name_length(string);
string[len] = 0;
return len;
}
static void stuff_priv(
qli_rlb* rlb,
USHORT type,
const TEXT* relation,
USHORT privileges, const TEXT* user, const TEXT* field)
{
/**************************************
*
* s t u f f _ p r i v
*
**************************************
*
* Functional description
* Stuff a privilege for grant/revoke.
*
**************************************/
rlb = CHECK_RLB(rlb);
STUFF(type);
// Stuff privileges first
USHORT priv_count = 0;
if (privileges & PRV_select)
priv_count++;
if (privileges & PRV_insert)
priv_count++;
if (privileges & PRV_delete)
priv_count++;
if (privileges & PRV_update)
priv_count++;
STUFF_WORD(priv_count);
if (privileges & PRV_select)
STUFF('S');
if (privileges & PRV_insert)
STUFF('I');
if (privileges & PRV_delete)
STUFF('D');
if (privileges & PRV_update)
STUFF('U');
STUFF(isc_dyn_rel_name);
STUFF_STRING(relation);
STUFF(isc_dyn_grant_user);
STUFF_STRING(user);
if (field) {
STUFF(isc_dyn_fld_name);
STUFF_STRING(field);
}
if (privileges & PRV_grant_option) {
STUFF(isc_dyn_grant_options);
STUFF_WORD(2);
STUFF_WORD(TRUE);
}
STUFF(isc_dyn_end);
}
View Git Blame Copy Permalink