File network_interface_cl.c¶
File List > communication > network_interface_cl.c
Go to the documentation of this file
/*
* Copyright 2008 Search Solution Corporation
* Copyright 2016 CUBRID Corporation
*
* Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/*
* network_interface_cl.c - Interface functions for client requests.
*/
#ident "$Id$"
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <algorithm>
#include "porting.h"
#include "network.h"
#include "network_interface_cl.h"
#include "memory_alloc.h"
#include "mem_block.hpp"
#include "storage_common.h"
#if defined(CS_MODE)
#include "server_interface.h"
#include "boot_cl.h"
#include "schema_manager.h"
#else /* !defined (CS_MODE) == defined (SA_MODE) */
#include "xserver_interface.h"
#include "boot_sr.h"
#include "locator_sr.h"
#include "query_executor.h"
#include "transaction_sr.h"
#include "pl_sr.h"
#include "vacuum.h"
#include "serial.h"
#endif /* defined (SA_MODE) */
#include "oid.h"
#include "error_manager.h"
#include "object_primitive.h"
#include "object_representation.h"
#include "log_comm.h"
#include "log_writer.h"
#include "arithmetic.h"
#include "transaction_cl.h"
#include "language_support.h"
#include "statistics.h"
#include "system_parameter.h"
#include "replication.h"
#include "es.h"
#include "db.h"
#include "db_query.h"
#include "dbtype.h"
#include "compile_context.h"
#if defined (SA_MODE)
#include "thread_manager.hpp"
#include "pl_compile_handler.hpp"
#include "pl_executor.hpp"
#endif // SA_MODE
#include "xasl.h"
#include "lob_locator.hpp"
#include "crypt_opfunc.h"
#include "method_error.hpp"
#include "message_catalog.h"
#include "utility.h"
#include "sp_constants.hpp"
#include "locator_cl.h"
/*
* Use db_clear_private_heap instead of db_destroy_private_heap
*/
#define NET_COPY_AREA_SENDRECV_SIZE (OR_INT_SIZE * 3)
#define NET_SENDRECV_BUFFSIZE (OR_INT_SIZE)
#if defined (CS_MODE)
#define NET_DEFER_END_QUERIES_MAX 5
static QUERY_ID net_Deferred_end_queries[NET_DEFER_END_QUERIES_MAX];
static int net_Deferred_end_queries_count = 0;
#endif /* CS_MODE */
/*
* Flag to indicate whether we've crossed the client/server boundary.
* It really only comes into play in standalone.
*/
unsigned int db_on_server = 0;
#if defined(CS_MODE)
static char *pack_const_string (char *buffer, const char *cstring);
static char *pack_string_with_null_padding (char *buffer, const char *stream, int len);
static int length_const_string (const char *cstring, int *strlen);
static int length_string_with_null_padding (int len);
#endif /* CS_MODE */
#if defined (SA_MODE)
static void enter_server_no_thread_entry (void);
static THREAD_ENTRY *enter_server (void);
static void exit_server_no_thread_entry (void);
static void exit_server (const THREAD_ENTRY & thread_ref);
#endif // SERVER_MODE
static int is_top_level_class (MOBJ mobj);
#if defined (SA_MODE)
//
// enter_server_no_thread_entry () - enter server mode without getting a thread entry (e.g. when "starting" server).
//
static void
enter_server_no_thread_entry (void)
{
db_on_server++;
er_stack_push_if_exists ();
if (private_heap_id == 0)
{
assert (db_on_server == 1);
private_heap_id = db_create_private_heap ();
}
}
//
// enter_server () - start simulating server mode
//
// return : pointer to thread entry
//
static THREAD_ENTRY *
enter_server ()
{
enter_server_no_thread_entry ();
return thread_get_thread_entry_info ();
}
//
// exit_server_no_thread_entry () - exit server mode without getting a thread entry (e.g. when "starting" server).
//
static void
exit_server_no_thread_entry (void)
{
if ((db_on_server - 1) == 0 && private_heap_id != 0)
{
db_clear_private_heap (NULL, private_heap_id);
}
er_restore_last_error ();
db_on_server--;
}
//
// exit_server () - exit server mode simulation
//
// thread_ref (in) : reference to thread entry used to enter server mode
//
static void
exit_server (const THREAD_ENTRY & thread_ref)
{
(void) thread_ref; // not really used; just to force caller declare obtain thread entry
exit_server_no_thread_entry ();
}
#endif // SA_MODE
#if defined(CS_MODE)
/*
* pack_const_string -
*
* return:
*
* buffer(in):
* cstring(in):
*
* NOTE:
*/
static char *
pack_const_string (char *buffer, const char *cstring)
{
return or_pack_string (buffer, cstring);
}
/*
* pack_string_with_null_padding - pack stream and add null.
* so stream is made as null terminated string.
*
* return:
*
* buffer(in):
* stream(in):
* len(in):
*
* NOTE:
*/
static char *
pack_string_with_null_padding (char *buffer, const char *stream, int len)
{
return or_pack_string_with_null_padding (buffer, stream, len);
}
/*
* pack_const_string_with_length -
*
* return:
*
* buffer(in):
* cstring(in):
* strlen(in):
*
* NOTE:
*/
static char *
pack_const_string_with_length (char *buffer, const char *cstring, int strlen)
{
return or_pack_string_with_length (buffer, cstring, strlen);
}
/*
* length_const_string -
*
* return:
*
* cstring(in):
* strlen(out): strlen(cstring)
*/
static int
length_const_string (const char *cstring, int *strlen)
{
return or_packed_string_length (cstring, strlen);
}
/*
* length_string_with_null_padding - calculate length with null padding
*
* return:
*
* len(in): stream length
*/
static int
length_string_with_null_padding (int len)
{
return or_packed_stream_length (len + 1); /* 1 for NULL padding */
}
#endif /* CS_MODE */
/*
* locator_fetch -
*
* return:
*
* oidp(in):
* chn(in):
* lock(in):
* fetch_type(in): fetch version type
* class_oid(in):
* class_chn(in):
* prefetch(in):
* fetch_copyarea(in):
*/
int
locator_fetch (OID * oidp, int chn, LOCK lock, LC_FETCH_VERSION_TYPE fetch_version_type, OID * class_oid, int class_chn,
int prefetch, LC_COPYAREA ** fetch_copyarea)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
char *ptr;
OR_ALIGNED_BUF ((OR_OID_SIZE * 2) + (OR_INT_SIZE * 5)) a_request;
char *request;
OR_ALIGNED_BUF (NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
assert (oidp->volid >= 0 && oidp->pageid >= 0 && oidp->slotid >= 0);
ptr = or_pack_oid (request, oidp);
ptr = or_pack_int (ptr, chn);
ptr = or_pack_lock (ptr, lock);
ptr = or_pack_int (ptr, (int) fetch_version_type);
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, class_chn);
ptr = or_pack_int (ptr, prefetch);
*fetch_copyarea = NULL;
req_error =
net_client_request_recv_copyarea (NET_SERVER_LC_FETCH, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), fetch_copyarea);
if (!req_error)
{
ptr = reply + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_int (ptr, &success);
}
else
{
*fetch_copyarea = NULL;
}
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success =
xlocator_fetch (thread_p, oidp, chn, lock, fetch_version_type, fetch_version_type, class_oid, class_chn, prefetch,
fetch_copyarea);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_get_class -
*
* return:
*
* class_oid(in):
* class_chn(in):
* oid(in):
* lock(in):
* prefetching(in):
* fetch_copyarea(in):
*
* NOTE:
*/
int
locator_get_class (OID * class_oid, int class_chn, const OID * oid, LOCK lock, int prefetching,
LC_COPYAREA ** fetch_copyarea)
{
#if defined(CS_MODE)
int req_error;
char *ptr;
int return_value = ER_FAILED;
OR_ALIGNED_BUF ((OR_OID_SIZE * 2) + (OR_INT_SIZE * 3)) a_request;
char *request;
OR_ALIGNED_BUF (NET_COPY_AREA_SENDRECV_SIZE + OR_OID_SIZE + OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, class_oid);
ptr = or_pack_int (ptr, class_chn);
ptr = or_pack_oid (ptr, (OID *) oid);
ptr = or_pack_lock (ptr, lock);
ptr = or_pack_int (ptr, prefetching);
*fetch_copyarea = NULL;
req_error =
net_client_request_recv_copyarea (NET_SERVER_LC_GET_CLASS, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), fetch_copyarea);
if (!req_error)
{
ptr = reply + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_oid (ptr, class_oid);
ptr = or_unpack_int (ptr, &return_value);
}
else
{
*fetch_copyarea = NULL;
}
return return_value;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_get_class (thread_p, class_oid, class_chn, oid, lock, prefetching, fetch_copyarea);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_fetch_all -
*
* return:
*
* hfid(in):
* lock(in):
* fetch_version_type(in): fetch version type
* class_oidp(in):
* nobjects(in):
* nfetched(in):
* last_oidp(in):
* fetch_copyarea(in):
*
* NOTE:
*/
int
locator_fetch_all (const HFID * hfid, LOCK * lock, LC_FETCH_VERSION_TYPE fetch_version_type, OID * class_oidp,
int *nobjects, int *nfetched, OID * last_oidp, LC_COPYAREA ** fetch_copyarea,
int request_pages, int nparallel_process, int nparallel_process_idx)
{
#if defined(CS_MODE)
int req_error;
char *ptr;
int return_value = ER_FAILED;
int client_endian = (int) get_endian_type ();
OR_ALIGNED_BUF (OR_HFID_SIZE + (OR_INT_SIZE * 8) + (OR_OID_SIZE * 2)) a_request;
char *request;
OR_ALIGNED_BUF (NET_COPY_AREA_SENDRECV_SIZE + (OR_INT_SIZE * 5) + OR_OID_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_lock (ptr, *lock);
ptr = or_pack_int (ptr, fetch_version_type);
ptr = or_pack_oid (ptr, class_oidp);
ptr = or_pack_int (ptr, *nobjects);
ptr = or_pack_int (ptr, *nfetched);
ptr = or_pack_oid (ptr, last_oidp);
ptr = or_pack_int (ptr, request_pages);
ptr = or_pack_int (ptr, nparallel_process);
ptr = or_pack_int (ptr, nparallel_process_idx);
ptr = or_pack_int (ptr, client_endian);
*fetch_copyarea = NULL;
req_error =
net_client_request_recv_copyarea (NET_SERVER_LC_FETCHALL, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), fetch_copyarea);
if (req_error == NO_ERROR)
{
ptr = reply + NET_COPY_AREA_SENDRECV_SIZE;
ptr += OR_INT_SIZE; // or_unpack_int (ptr, &client_endian);
ptr = or_unpack_lock (ptr, lock);
ptr = or_unpack_int (ptr, nobjects);
ptr = or_unpack_int (ptr, nfetched);
ptr = or_unpack_oid (ptr, last_oidp);
ptr = or_unpack_int (ptr, &return_value);
}
else
{
*fetch_copyarea = NULL;
}
return return_value;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
assert ((nparallel_process <= 1) || (nparallel_process_idx >= 0 && nparallel_process_idx < nparallel_process));
if (nparallel_process > 1)
{
thread_p->_unload_cnt_parallel_process = nparallel_process;
thread_p->_unload_parallel_process_idx = nparallel_process_idx;
}
else
{
thread_p->_unload_cnt_parallel_process = NO_UNLOAD_PARALLEL_PROCESSIING;
thread_p->_unload_parallel_process_idx = NO_UNLOAD_PARALLEL_PROCESSIING;
}
success =
xlocator_fetch_all (thread_p, hfid, lock, fetch_version_type, class_oidp, nobjects, nfetched, last_oidp,
fetch_copyarea, request_pages);
if (nparallel_process > 1)
{
thread_p->_unload_cnt_parallel_process = NO_UNLOAD_PARALLEL_PROCESSIING;
thread_p->_unload_parallel_process_idx = NO_UNLOAD_PARALLEL_PROCESSIING;
}
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_does_exist -
*
* return:
*
* oidp(in):
* chn(in):
* lock(in):
* class_oid(in):
* class_chn(in):
* need_fetching(in):
* prefetch(in):
* fetch_copyarea(in):
*
* NOTE:
*/
int
locator_does_exist (OID * oidp, int chn, LOCK lock, OID * class_oid, int class_chn, int need_fetching, int prefetch,
LC_COPYAREA ** fetch_copyarea, LC_FETCH_VERSION_TYPE fetch_version_type)
{
#if defined(CS_MODE)
int does_exist = LC_ERROR;
int req_error;
char *ptr;
OR_ALIGNED_BUF ((OR_OID_SIZE * 2) + (OR_INT_SIZE * 6)) a_request;
char *request;
OR_ALIGNED_BUF (NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE + OR_OID_SIZE) a_reply;
char *reply;
OID class_;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, oidp);
ptr = or_pack_int (ptr, chn);
ptr = or_pack_lock (ptr, lock);
ptr = or_pack_int (ptr, (int) fetch_version_type);
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, class_chn);
ptr = or_pack_int (ptr, need_fetching);
ptr = or_pack_int (ptr, prefetch);
if (fetch_copyarea != NULL && need_fetching)
{
*fetch_copyarea = NULL;
}
req_error =
net_client_request_recv_copyarea (NET_SERVER_LC_DOESEXIST, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), fetch_copyarea);
if (!req_error)
{
ptr = reply + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_int (ptr, &does_exist);
ptr = or_unpack_oid (ptr, &class_);
if (does_exist == LC_EXIST && class_oid)
{
COPY_OID (class_oid, &class_);
}
}
else if (fetch_copyarea != NULL)
{
*fetch_copyarea = NULL;
}
return does_exist;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success =
xlocator_does_exist (thread_p, oidp, chn, lock, fetch_version_type, class_oid, class_chn, need_fetching, prefetch,
fetch_copyarea);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_notify_isolation_incons -
*
* return:
*
* synch_copyarea(in):
*
* NOTE:
*/
int
locator_notify_isolation_incons (LC_COPYAREA ** synch_copyarea)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
char *ptr;
OR_ALIGNED_BUF (NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
*synch_copyarea = NULL;
req_error =
net_client_request_recv_copyarea (NET_SERVER_LC_NOTIFY_ISOLATION_INCONS, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), synch_copyarea);
if (!req_error)
{
ptr = reply + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_int (ptr, &success);
}
else
{
*synch_copyarea = NULL;
}
return (success);
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_notify_isolation_incons (thread_p, synch_copyarea);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_repl_force - flush copy area containing replication objects and receive error occurred in server
*
* return:
*
* copy_area(in):
* reply_copy_area(out):
*
* NOTE:
*/
int
locator_repl_force (LC_COPYAREA * copy_area, LC_COPYAREA ** reply_copy_area)
{
#if defined(CS_MODE)
int error_code = ER_FAILED;
OR_ALIGNED_BUF (NET_COPY_AREA_SENDRECV_SIZE) a_request;
char *request;
char *request_ptr;
OR_ALIGNED_BUF (NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE) a_reply;
char *reply;
char *desc_ptr = NULL;
int desc_size;
char *content_ptr;
int content_size;
int num_objs = 0;
int req_error;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
num_objs = locator_send_copy_area (copy_area, &content_ptr, &content_size, &desc_ptr, &desc_size, true);
request_ptr = or_pack_int (request, num_objs);
request_ptr = or_pack_int (request_ptr, desc_size);
request_ptr = or_pack_int (request_ptr, content_size);
req_error =
net_client_request_3_data_recv_copyarea (NET_SERVER_LC_REPL_FORCE, request,
NET_COPY_AREA_SENDRECV_SIZE, desc_ptr, desc_size,
content_ptr, content_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), reply_copy_area);
if (req_error == NO_ERROR)
{
/* skip first 3 */
(void) or_unpack_int (reply + NET_COPY_AREA_SENDRECV_SIZE, &error_code);
}
else
{
assert (er_errid () != NO_ERROR);
error_code = er_errid ();
}
if (desc_ptr)
{
free_and_init (desc_ptr);
}
return error_code;
#else /* CS_MODE */
/* Not allowed in SA_MODE */
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* locator_force -
*
* return:
*
* copy_area(in):
*
* NOTE:
*/
int
locator_force (LC_COPYAREA * copy_area, int num_ignore_error_list, int *ignore_error_list, int content_size)
{
#if defined(CS_MODE)
int error_code = ER_FAILED;
char *request;
char *request_ptr;
int request_size;
OR_ALIGNED_BUF (OR_INT_SIZE * 3) a_reply;
char *reply;
char *desc_ptr = NULL;
int desc_size;
char *content_ptr;
int num_objs = 0;
int req_error;
int i;
LC_COPYAREA_MANYOBJS *mobjs;
mobjs = LC_MANYOBJS_PTR_IN_COPYAREA (copy_area);
request_size = OR_INT_SIZE * (5 + num_ignore_error_list);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
reply = OR_ALIGNED_BUF_START (a_reply);
num_objs = locator_send_copy_area (copy_area, &content_ptr, NULL, &desc_ptr, &desc_size, true);
request_ptr = or_pack_int (request, num_objs);
request_ptr = or_pack_int (request_ptr, mobjs->multi_update_flags);
// unset start_multi_update flag after first request containing it set
if (locator_manyobj_flag_is_set (mobjs, START_MULTI_UPDATE))
{
locator_manyobj_flag_remove (mobjs, START_MULTI_UPDATE);
}
request_ptr = or_pack_int (request_ptr, desc_size);
request_ptr = or_pack_int (request_ptr, content_size);
request_ptr = or_pack_int (request_ptr, num_ignore_error_list);
for (i = 0; i < num_ignore_error_list; i++)
{
request_ptr = or_pack_int (request_ptr, ignore_error_list[i]);
}
req_error =
net_client_request_3_data (NET_SERVER_LC_FORCE, request, request_size, desc_ptr, desc_size,
content_ptr, content_size, reply, OR_ALIGNED_BUF_SIZE (a_reply),
desc_ptr, desc_size, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &error_code);
if (error_code == NO_ERROR)
{
locator_unpack_copy_area_descriptor (num_objs, copy_area, desc_ptr, -1);
}
}
if (desc_ptr)
{
free_and_init (desc_ptr);
}
if (request)
{
free_and_init (request);
}
return error_code;
#else /* CS_MODE */
int error_code = ER_FAILED;
LC_COPYAREA *copy_area_clone;
/* If xlocator_force returns error, the original copy_area should not be changed. So copy_area_clone will be used. */
copy_area_clone = locator_allocate_copy_area_by_length (copy_area->length);
if (copy_area_clone == NULL)
{
return ER_OUT_OF_VIRTUAL_MEMORY;
}
memcpy (copy_area_clone->mem, copy_area->mem, copy_area->length);
THREAD_ENTRY *thread_p = enter_server ();
error_code = xlocator_force (thread_p, copy_area, num_ignore_error_list, ignore_error_list);
exit_server (*thread_p);
if (error_code != NO_ERROR)
{
/* Restore copy_area */
memcpy (copy_area->mem, copy_area_clone->mem, copy_area->length);
}
locator_free_copy_area (copy_area_clone);
return error_code;
#endif /* !CS_MODE */
}
/*
* locator_fetch_lockset -
*
* return:
*
* lockset(in):
* fetch_copyarea(in):
*
* NOTE:
*/
int
locator_fetch_lockset (LC_LOCKSET * lockset, LC_COPYAREA ** fetch_copyarea)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
char *ptr;
OR_ALIGNED_BUF (NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
char *packed = NULL;
int packed_size;
int send_size;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
if (lockset->first_fetch_lockset_call == true)
{
send_size = locator_pack_lockset (lockset, true, true);
packed = lockset->packed;
packed_size = lockset->packed_size;
if (!packed)
{
return ER_FAILED;
}
ptr = or_pack_int (request, send_size);
req_error =
net_client_request_2recv_copyarea (NET_SERVER_LC_FETCH_LOCKSET, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), packed, send_size, packed, packed_size,
fetch_copyarea, &lockset->eid);
}
else
{
/* Don't need to send the lockset information any more */
packed = lockset->packed;
packed_size = lockset->packed_size;
req_error =
net_client_recv_copyarea (NET_SERVER_LC_FETCH_LOCKSET, reply, OR_ALIGNED_BUF_SIZE (a_reply), packed,
packed_size, fetch_copyarea, lockset->eid);
}
if (!req_error)
{
ptr = reply + NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_int (ptr, &success);
if (success == NO_ERROR)
{
locator_unpack_lockset (lockset, lockset->first_fetch_lockset_call, false);
}
}
else
{
*fetch_copyarea = NULL;
}
/*
* We will not need to send the lockset structure any more. We do not
* need to receive the classes and objects in the lockset structure
* any longer
*/
lockset->first_fetch_lockset_call = false;
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_fetch_lockset (thread_p, lockset, fetch_copyarea);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_fetch_all_reference_lockset -
*
* return:
*
* oid(in):
* chn(in):
* class_oid(in):
* class_chn(in):
* lock(in):
* quit_on_errors(in):
* prune_level(in):
* lockset(in):
* fetch_copyarea(in):
*
* NOTE:
*/
int
locator_fetch_all_reference_lockset (OID * oid, int chn, OID * class_oid, int class_chn, LOCK lock, int quit_on_errors,
int prune_level, LC_LOCKSET ** lockset, LC_COPYAREA ** fetch_copyarea)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
char *ptr;
OR_ALIGNED_BUF ((OR_OID_SIZE * 2) + (OR_INT_SIZE * 5)) a_request;
char *request;
OR_ALIGNED_BUF (NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE) a_reply;
char *reply;
char *packed;
int packed_size;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
*fetch_copyarea = NULL;
*lockset = NULL;
ptr = or_pack_oid (request, oid);
ptr = or_pack_int (ptr, chn);
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, class_chn);
ptr = or_pack_lock (ptr, lock);
ptr = or_pack_int (ptr, quit_on_errors);
ptr = or_pack_int (ptr, prune_level);
req_error =
net_client_request_3recv_copyarea (NET_SERVER_LC_FETCH_ALLREFS_LOCKSET, request,
OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &packed, &packed_size, fetch_copyarea);
if (!req_error)
{
ptr = reply + NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_int (ptr, &success);
if (packed_size > 0 && packed != NULL)
{
*lockset = locator_allocate_and_unpack_lockset (packed, packed_size, true, true, false);
}
else
{
*lockset = NULL;
}
if (packed)
{
free_and_init (packed);
}
}
else
{
*fetch_copyarea = NULL;
*lockset = NULL;
}
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success =
xlocator_fetch_all_reference_lockset (thread_p, oid, chn, class_oid, class_chn, lock, quit_on_errors, prune_level,
lockset, fetch_copyarea);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_find_class_oid -
*
* return:
*
* class_name(in):
* class_oid(in):
* lock(in):
*
* NOTE:
*/
LC_FIND_CLASSNAME
locator_find_class_oid (const char *class_name, OID * class_oid, LOCK lock)
{
#if defined(CS_MODE)
LC_FIND_CLASSNAME found = LC_CLASSNAME_ERROR;
int xfound;
int req_error;
char *ptr;
int request_size, strlen;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_OID_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (class_name, &strlen) + OR_OID_SIZE + OR_INT_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return LC_CLASSNAME_ERROR;
}
ptr = pack_const_string_with_length (request, class_name, strlen);
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_lock (ptr, lock);
req_error = net_client_request (NET_SERVER_LC_FIND_CLASSOID, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &xfound);
found = (LC_FIND_CLASSNAME) xfound;
ptr = or_unpack_oid (ptr, class_oid);
}
free_and_init (request);
return found;
#else /* CS_MODE */
LC_FIND_CLASSNAME found = LC_CLASSNAME_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
found = xlocator_find_class_oid (thread_p, class_name, class_oid, lock);
exit_server (*thread_p);
return found;
#endif /* !CS_MODE */
}
/*
* locator_reserve_class_names -
*
* return:
*
* num_classes(in)
* class_names(in):
* class_oids(in):
*
* NOTE:
*/
LC_FIND_CLASSNAME
locator_reserve_class_names (const int num_classes, const char **class_names, OID * class_oids)
{
#if defined(CS_MODE)
LC_FIND_CLASSNAME reserved = LC_CLASSNAME_ERROR;
int xreserved;
int request_size;
int req_error;
char *request, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
int i;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = OR_INT_SIZE;
for (i = 0; i < num_classes; ++i)
{
request_size += length_const_string (class_names[i], NULL) + OR_OID_SIZE;
}
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return LC_CLASSNAME_ERROR;
}
ptr = or_pack_int (request, num_classes);
for (i = 0; i < num_classes; ++i)
{
ptr = pack_const_string (ptr, class_names[i]);
ptr = or_pack_oid (ptr, &class_oids[i]);
}
req_error = net_client_request (NET_SERVER_LC_RESERVE_CLASSNAME, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &xreserved);
reserved = (LC_FIND_CLASSNAME) xreserved;
}
free_and_init (request);
return reserved;
#else /* CS_MODE */
LC_FIND_CLASSNAME reserved = LC_CLASSNAME_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
reserved = xlocator_reserve_class_names (thread_p, num_classes, class_names, class_oids);
exit_server (*thread_p);
return reserved;
#endif /* !CS_MODE */
}
/*
* locator_get_reserved_class_name_oid () - Get OID of reserved class.
*
* return : Error code.
* classname (in) : Class name.
* class_oid (out) : Class OID.
*/
int
locator_get_reserved_class_name_oid (const char *classname, OID * class_oid)
{
#if defined(CS_MODE)
int request_size;
int request_error = NO_ERROR;
char *request = NULL;
OR_ALIGNED_BUF (OR_OID_SIZE) a_reply;
char *reply = NULL;
assert (classname != NULL);
assert (class_oid != NULL);
OID_SET_NULL (class_oid);
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (classname, NULL);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
(void) pack_const_string (request, classname);
request_error =
net_client_request (NET_SERVER_LC_RESERVE_CLASSNAME_GET_OID, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
free_and_init (request);
if (request_error != NO_ERROR)
{
return request_error;
}
(void) or_unpack_oid (reply, class_oid);
return NO_ERROR;
#else
int is_reserved;
THREAD_ENTRY *thread_p = enter_server ();
is_reserved = xlocator_get_reserved_class_name_oid (thread_p, classname, class_oid);
exit_server (*thread_p);
return is_reserved;
#endif
}
/*
* locator_delete_class_name -
*
* return:
*
* class_name(in):
*
* NOTE:
*/
LC_FIND_CLASSNAME
locator_delete_class_name (const char *class_name)
{
#if defined(CS_MODE)
LC_FIND_CLASSNAME deleted = LC_CLASSNAME_ERROR;
int xdeleted;
int req_error, request_size, strlen;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (class_name, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return LC_CLASSNAME_ERROR;
}
(void) pack_const_string_with_length (request, class_name, strlen);
req_error = net_client_request (NET_SERVER_LC_DELETE_CLASSNAME, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &xdeleted);
deleted = (LC_FIND_CLASSNAME) xdeleted;
}
free_and_init (request);
return deleted;
#else /* CS_MODE */
LC_FIND_CLASSNAME deleted = LC_CLASSNAME_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
deleted = xlocator_delete_class_name (thread_p, class_name);
exit_server (*thread_p);
return deleted;
#endif /* !CS_MODE */
}
/*
* locator_rename_class_name -
*
* return:
*
* old_name(in):
* new_name(in):
* class_oid(in):
*
* NOTE:
*/
LC_FIND_CLASSNAME
locator_rename_class_name (const char *old_name, const char *new_name, OID * class_oid)
{
#if defined(CS_MODE)
LC_FIND_CLASSNAME renamed = LC_CLASSNAME_ERROR;
int xrenamed;
int request_size, strlen1, strlen2;
int req_error;
char *request, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (old_name, &strlen1) + length_const_string (new_name, &strlen2) + OR_OID_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return LC_CLASSNAME_ERROR;
}
ptr = pack_const_string_with_length (request, old_name, strlen1);
ptr = pack_const_string_with_length (ptr, new_name, strlen2);
ptr = or_pack_oid (ptr, class_oid);
req_error = net_client_request (NET_SERVER_LC_RENAME_CLASSNAME, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &xrenamed);
renamed = (LC_FIND_CLASSNAME) xrenamed;
}
free_and_init (request);
return renamed;
#else /* CS_MODE */
LC_FIND_CLASSNAME renamed = LC_CLASSNAME_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
renamed = xlocator_rename_class_name (thread_p, old_name, new_name, class_oid);
exit_server (*thread_p);
return renamed;
#endif /* !CS_MODE */
}
/*
* locator_assign_oid -
*
* return:
*
* hfid(in):
* perm_oid(in):
* expected_length(in):
* class_oid(in):
* class_name(in):
*
* NOTE:
*/
int
locator_assign_oid (const HFID * hfid, OID * perm_oid, int expected_length, OID * class_oid, const char *class_name)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int request_size, strlen;
int req_error;
char *request, *ptr;
OR_ALIGNED_BUF (OR_OID_SIZE + OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = OR_HFID_SIZE + OR_INT_SIZE + OR_OID_SIZE + length_const_string (class_name, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_int (ptr, expected_length);
ptr = or_pack_oid (ptr, class_oid);
ptr = pack_const_string_with_length (ptr, class_name, strlen);
req_error = net_client_request (NET_SERVER_LC_ASSIGN_OID, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
ptr = or_unpack_oid (ptr, perm_oid);
}
free_and_init (request);
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_assign_oid (thread_p, hfid, perm_oid, expected_length, class_oid, class_name);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_assign_oid_batch -
*
* return:
*
* oidset(in):
*
* NOTE:
*/
int
locator_assign_oid_batch (LC_OIDSET * oidset)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int packed_size;
char *buffer, *ptr;
int req_error;
/*
* Build a buffer in which to send and receive the goobers. We'll
* reuse the same buffer to receive the data as we used to send it.
* First word is reserved for the return code.
*/
packed_size = locator_get_packed_oid_set_size (oidset) + OR_INT_SIZE;
buffer = (char *) malloc (packed_size);
if (buffer == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) packed_size);
return ER_FAILED;
}
ptr = buffer;
ptr = or_pack_int (ptr, 0);
if (locator_pack_oid_set (ptr, oidset) == NULL)
{
free_and_init (buffer);
return ER_FAILED;
}
req_error =
net_client_request (NET_SERVER_LC_ASSIGN_OID_BATCH, buffer, packed_size, buffer, packed_size, NULL, 0, NULL, 0);
if (!req_error)
{
ptr = buffer;
ptr = or_unpack_int (ptr, &success);
if (success == NO_ERROR)
{
if (locator_unpack_oid_set_to_exist (ptr, oidset) == false)
{
success = ER_FAILED;
}
}
}
free_and_init (buffer);
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_assign_oid_batch (thread_p, oidset);
exit_server (*thread_p);
return (success);
#endif /* !CS_MODE */
}
/*
* locator_find_lockhint_class_oids -
*
* return:
*
* num_classes(in):
* many_classnames(in):
* many_locks(in):
* many_need_subclasses(in):
* many_flags(in):
* guessed_class_oids(in):
* guessed_class_chns(in):
* quit_on_errors(in):
* lock_rr_tran(in):
* lockhint(in):
* fetch_copyarea(in):
*
* NOTE:
*/
LC_FIND_CLASSNAME
locator_find_lockhint_class_oids (int num_classes, const char **many_classnames, LOCK * many_locks,
int *many_need_subclasses, LC_PREFETCH_FLAGS * many_flags, OID * guessed_class_oids,
int *guessed_class_chns, int quit_on_errors, LOCK lock_rr_tran,
LC_LOCKHINT ** lockhint, LC_COPYAREA ** fetch_copyarea)
{
#if defined(CS_MODE)
LC_FIND_CLASSNAME allfind = LC_CLASSNAME_ERROR;
int xallfind;
int req_error;
char *ptr;
int request_size;
char *request, *packed;
int packed_size;
OR_ALIGNED_BUF (NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE) a_reply;
char *reply;
int i;
reply = OR_ALIGNED_BUF_START (a_reply);
*lockhint = NULL;
*fetch_copyarea = NULL;
request_size = OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE;
for (i = 0; i < num_classes; i++)
{
request_size += (length_const_string (many_classnames[i], NULL) + OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE
+ OR_OID_SIZE + OR_INT_SIZE);
}
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return allfind;
}
ptr = or_pack_int (request, num_classes);
ptr = or_pack_int (ptr, quit_on_errors);
ptr = or_pack_int (ptr, (int) lock_rr_tran);
for (i = 0; i < num_classes; i++)
{
ptr = pack_const_string (ptr, many_classnames[i]);
ptr = or_pack_lock (ptr, many_locks[i]);
ptr = or_pack_int (ptr, many_need_subclasses[i]);
ptr = or_pack_int (ptr, (int) many_flags[i]);
ptr = or_pack_oid (ptr, &guessed_class_oids[i]);
ptr = or_pack_int (ptr, guessed_class_chns[i]);
}
req_error =
net_client_request_3recv_copyarea (NET_SERVER_LC_FIND_LOCKHINT_CLASSOIDS, request, request_size,
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &packed,
&packed_size, fetch_copyarea);
if (!req_error)
{
ptr = reply + NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_int (ptr, &xallfind);
allfind = (LC_FIND_CLASSNAME) xallfind;
if (packed_size > 0 && packed != NULL)
{
*lockhint = locator_allocate_and_unpack_lockhint (packed, packed_size, true, false);
}
else
{
*lockhint = NULL;
}
if (packed)
{
free_and_init (packed);
}
}
else
{
*lockhint = NULL;
*fetch_copyarea = NULL;
}
if (request != NULL)
{
free_and_init (request);
}
tm_Tran_rep_read_lock = lock_rr_tran;
return allfind;
#else /* CS_MODE */
LC_FIND_CLASSNAME allfind = LC_CLASSNAME_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
allfind =
xlocator_find_lockhint_class_oids (thread_p, num_classes, many_classnames, many_locks, many_need_subclasses,
many_flags, guessed_class_oids, guessed_class_chns, quit_on_errors, lockhint,
fetch_copyarea);
exit_server (*thread_p);
return allfind;
#endif /* !CS_MODE */
}
/*
* locator_fetch_lockhint_classes -
*
* return:
*
* lockhint(in):
* fetch_copyarea(in):
*
* NOTE:
*/
int
locator_fetch_lockhint_classes (LC_LOCKHINT * lockhint, LC_COPYAREA ** fetch_copyarea)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
char *ptr;
OR_ALIGNED_BUF (NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE + OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
char *packed = NULL;
int packed_size;
int send_size;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
*fetch_copyarea = NULL;
if (lockhint->first_fetch_lockhint_call == true)
{
send_size = locator_pack_lockhint (lockhint, true);
packed = lockhint->packed;
packed_size = lockhint->packed_size;
if (!packed)
{
return ER_FAILED;
}
ptr = or_pack_int (request, send_size);
req_error =
net_client_request_2recv_copyarea (NET_SERVER_LC_FETCH_LOCKHINT_CLASSES, request,
OR_ALIGNED_BUF_SIZE (a_request), reply, OR_ALIGNED_BUF_SIZE (a_reply),
packed, send_size, packed, packed_size, fetch_copyarea, &lockhint->eid);
}
else
{
/* Don't need to send the lockhint information any more */
packed = lockhint->packed;
packed_size = lockhint->packed_size;
req_error =
net_client_recv_copyarea (NET_SERVER_LC_FETCH_LOCKHINT_CLASSES, reply, OR_ALIGNED_BUF_SIZE (a_reply), packed,
packed_size, fetch_copyarea, lockhint->eid);
}
if (!req_error)
{
ptr = reply + NET_SENDRECV_BUFFSIZE + NET_COPY_AREA_SENDRECV_SIZE;
ptr = or_unpack_int (ptr, &success);
if (success == NO_ERROR)
{
locator_unpack_lockhint (lockhint, lockhint->first_fetch_lockhint_call);
}
}
else
{
*fetch_copyarea = NULL;
}
lockhint->first_fetch_lockhint_call = false;
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_fetch_lockhint_classes (thread_p, lockhint, fetch_copyarea);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* heap_create -
*
* return:
*
* hfid(in):
* class_oid(in):
* reuse_oid(in):
*
* NOTE:
*/
int
heap_create (HFID * hfid, const OID * class_oid, bool reuse_oid)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_HFID_SIZE + OR_OID_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_HFID_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_oid (ptr, (OID *) class_oid);
ptr = or_pack_int (ptr, (int) reuse_oid);
req_error =
net_client_request (NET_SERVER_HEAP_CREATE, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
ptr = or_unpack_hfid (ptr, hfid);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xheap_create (thread_p, hfid, class_oid, reuse_oid);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
#if defined(ENABLE_UNUSED_FUNCTION)
/*
* heap_destroy -
*
* return:
*
* hfid(in):
*
* NOTE:
*/
int
heap_destroy (const HFID * hfid)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_HFID_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_hfid (request, hfid);
req_error =
net_client_request (NET_SERVER_HEAP_DESTROY, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xheap_destroy (thread_p, hfid, NULL);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
#endif /* ENABLE_UNUSED_FUNCTION */
/*
* heap_destroy_newly_created -
*
* return:
*
* hfid(in):
*
* NOTE:
*/
int
heap_destroy_newly_created (const HFID * hfid, const OID * class_oid, const bool force)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_HFID_SIZE + OR_OID_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, (int) force);
req_error =
net_client_request (NET_SERVER_HEAP_DESTROY_WHEN_NEW, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xheap_destroy_newly_created (thread_p, hfid, class_oid, force);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* heap_get_class_num_objects_pages -
*
* return:
*
* hfid(in):
* approximation(in):
* nobjs(in):
* npages(in):
*
* NOTE:
*/
int
heap_get_class_num_objects_pages (HFID * hfid, int approximation, int *nobjs, int *npages)
{
#if defined(CS_MODE)
int req_error, status = ER_FAILED, num_objs, num_pages;
OR_ALIGNED_BUF (OR_HFID_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE * 3) a_reply;
char *reply;
char *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_int (ptr, approximation);
req_error =
net_client_request (NET_SERVER_HEAP_GET_CLASS_NOBJS_AND_NPAGES, request,
OR_ALIGNED_BUF_SIZE (a_request), reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &status);
ptr = or_unpack_int (ptr, &num_objs);
ptr = or_unpack_int (ptr, &num_pages);
*nobjs = (int) num_objs;
*npages = (int) num_pages;
}
return status;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xheap_get_class_num_objects_pages (thread_p, hfid, approximation, nobjs, npages);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* heap_has_instance -
*
* return:
*
* hfid(in):
* class_oid(in):
* has_visible_instance(in): true if we need to check for a visible record
*
* NOTE:
*/
int
heap_has_instance (HFID * hfid, OID * class_oid, int has_visible_instance)
{
#if defined(CS_MODE)
int req_error, status = ER_FAILED;
OR_ALIGNED_BUF (OR_HFID_SIZE + OR_OID_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
char *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, has_visible_instance);
req_error =
net_client_request (NET_SERVER_HEAP_HAS_INSTANCE, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &status);
}
return status;
#else /* CS_MODE */
int r = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
r = xheap_has_instance (thread_p, hfid, class_oid, has_visible_instance);
exit_server (*thread_p);
return r;
#endif /* !CS_MODE */
}
/*
* heap_reclaim_addresses -
*
* return:
*
* hfid(in):
* reclaim_mvcc_next_versions(in):
*
* NOTE:
*/
int
heap_reclaim_addresses (const HFID * hfid)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_HFID_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_hfid (request, hfid);
req_error =
net_client_request (NET_SERVER_HEAP_RECLAIM_ADDRESSES, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xheap_reclaim_addresses (thread_p, hfid);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* heap_get_maxslotted_reclength -
*
* return:
*
* maxslotted_reclength(out):
*
* NOTE:
*/
int
heap_get_maxslotted_reclength (int &maxslotted_reclength)
{
#if defined(CS_MODE)
int req_error, success = ER_FAILED;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_HEAP_GET_MAXSLOTTED_RECLENGTH, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &maxslotted_reclength);
success = NO_ERROR;
}
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xheap_get_maxslotted_reclength (maxslotted_reclength);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* file_apply_tde_to_class_files -
*
* return:
*
* class_oid(in):
*
* NOTE:
*/
int
file_apply_tde_to_class_files (const OID * class_oid)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_OID_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, class_oid);
req_error =
net_client_request (NET_SERVER_FILE_APPLY_TDE_TO_CLASS_FILES, request,
OR_ALIGNED_BUF_SIZE (a_request), reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xfile_apply_tde_to_class_files (thread_p, class_oid);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
#ifdef UNSTABLE_TDE_FOR_REPLICATION_LOG
/*
* tde_get_data_keys -
*
* return:
*
* dks(out):
*
* NOTE:
*/
int
tde_get_data_keys ()
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, area_size;
char *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply, *area;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request2 (NET_SERVER_TDE_GET_DATA_KEYS, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error);
if (area_size > 0)
{
ptr = or_unpack_stream (area, (char *) tde_Cipher.data_keys.perm_key, TDE_DATA_KEY_LENGTH);
ptr = or_unpack_stream (ptr, (char *) tde_Cipher.data_keys.temp_key, TDE_DATA_KEY_LENGTH);
ptr = or_unpack_stream (ptr, (char *) tde_Cipher.data_keys.log_key, TDE_DATA_KEY_LENGTH);
}
free_and_init (area);
}
return error;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
#endif /* UNSTABLE_TDE_FOR_REPLICATION_LOG */
/*
* tde_is_loaded -
*
* return:
*
*/
int
tde_is_loaded (int *is_loaded)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TDE_IS_LOADED, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void *) or_unpack_int (reply, is_loaded);
}
return NO_ERROR;
#else /* CS_MODE */
*is_loaded = tde_is_loaded ();
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* tde_get_mk_file_path -
*
* return:
*
* dks(out):
*
* NOTE:
*/
int
tde_get_mk_file_path (char *mk_path)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, area_size;
char *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply, *area;
char *path = NULL;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request2 (NET_SERVER_TDE_GET_MK_FILE_PATH, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error);
if (area_size > 0)
{
ptr = or_unpack_string_nocopy (area, &path);
strncpy (mk_path, path, DB_MAX_PATH_LENGTH);
}
free_and_init (area);
}
return error;
#else /* CS_MODE */
tde_make_keys_file_fullname (mk_path, boot_db_full_name (), false);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* tde_get_set_mk_info -
*
* return:
*
* dks(out):
*
* NOTE:
*/
int
tde_get_mk_info (int *mk_index, time_t * created_time, time_t * set_time)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, area_size;
char *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE + OR_BIGINT_SIZE + OR_BIGINT_SIZE) a_reply;
char *reply, *area;
char *path = NULL;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TDE_GET_MK_INFO, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
ptr = or_unpack_int (ptr, mk_index);
ptr = or_unpack_int64 (ptr, created_time);
ptr = or_unpack_int64 (ptr, set_time);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xtde_get_mk_info (thread_p, mk_index, created_time, set_time);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* tde_change_mk_server -
*
* return:
*
* dks(out):
*
* NOTE:
*/
int
tde_change_mk_on_server (int mk_index)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_int (request, mk_index);
req_error =
net_client_request (NET_SERVER_TDE_CHANGE_MK_ON_SERVER, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xtde_change_mk_without_flock (thread_p, mk_index);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* disk_get_total_numpages -
*
* return:
*
* volid(in):
*
* NOTE:
*/
DKNPAGES
disk_get_total_numpages (VOLID volid)
{
#if defined(CS_MODE)
DKNPAGES npages = 0;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, (int) volid);
req_error =
net_client_request (NET_SERVER_DISK_TOTALPGS, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &npages);
}
return npages;
#else /* CS_MODE */
DKNPAGES npages = 0;
THREAD_ENTRY *thread_p = enter_server ();
npages = xdisk_get_total_numpages (thread_p, volid);
exit_server (*thread_p);
return npages;
#endif /* !CS_MODE */
}
/*
* disk_get_free_numpages -
*
* return:
*
* volid(in):
*
* NOTE:
*/
DKNPAGES
disk_get_free_numpages (VOLID volid)
{
#if defined(CS_MODE)
DKNPAGES npages = 0;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, (int) volid);
req_error =
net_client_request (NET_SERVER_DISK_FREEPGS, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &npages);
}
return npages;
#else /* CS_MODE */
DKNPAGES npages = 0;
THREAD_ENTRY *thread_p = enter_server ();
npages = xdisk_get_free_numpages (thread_p, volid);
exit_server (*thread_p);
return npages;
#endif /* !CS_MODE */
}
/*
* disk_get_remarks -
*
* return:
*
* volid(in):
*
* NOTE:
*/
char *
disk_get_remarks (VOLID volid)
{
#if defined(CS_MODE)
int req_error;
char *area = NULL;
int area_size;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
char *remark = NULL, *p = NULL;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, (int) volid);
req_error =
net_client_request2 (NET_SERVER_DISK_REMARKS, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (!req_error && area != NULL)
{
or_unpack_int (reply, &area_size);
or_unpack_string_nocopy (area, &p);
if (p != NULL)
{
remark = strdup (p);
}
free_and_init (area);
}
return remark;
#else /* CS_MODE */
char *remark = NULL;
THREAD_ENTRY *thread_p = enter_server ();
remark = xdisk_get_remarks (thread_p, volid);
exit_server (*thread_p);
return remark;
#endif /* !CS_MODE */
}
/*
* disk_get_fullname -
*
* return:
*
* volid(in):
* vol_fullname(in):
*
* NOTE:
*/
char *
disk_get_fullname (VOLID volid, char *vol_fullname)
{
#if defined(CS_MODE)
int req_error;
char *area = NULL;
int area_size;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
char *name = NULL;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, (int) volid);
req_error =
net_client_request2 (NET_SERVER_DISK_VLABEL, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (!req_error && area != NULL)
{
or_unpack_int (reply, &area_size);
or_unpack_string_nocopy (area, &name);
if (name != NULL)
{
strcpy (vol_fullname, name);
}
free_and_init (area);
}
else
{
vol_fullname = NULL;
}
return vol_fullname;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
vol_fullname = xdisk_get_fullname (thread_p, volid, vol_fullname);
exit_server (*thread_p);
return vol_fullname;
#endif /* !CS_MODE */
}
/*
* log_reset_wait_msecs -
*
* return:
*
* wait_msecs(in): in milliseconds
*
* NOTE:
*/
int
log_reset_wait_msecs (int wait_msecs)
{
#if defined(CS_MODE)
int wait = -1;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, wait_msecs);
req_error =
net_client_request (NET_SERVER_LOG_RESET_WAIT_MSECS, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &wait);
}
return wait;
#else /* CS_MODE */
int wait = -1;
THREAD_ENTRY *thread_p = enter_server ();
wait = xlogtb_reset_wait_msecs (thread_p, wait_msecs);
exit_server (*thread_p);
return wait;
#endif /* !CS_MODE */
}
/*
* log_reset_isolation -
*
* return:
*
* isolation(in):
*
* NOTE:
*/
int
log_reset_isolation (TRAN_ISOLATION isolation)
{
#if defined(CS_MODE)
int req_error, error_code = ER_NET_CLIENT_DATA_RECEIVE;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_int (request, (int) isolation);
req_error =
net_client_request (NET_SERVER_LOG_RESET_ISOLATION, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &error_code);
}
return error_code;
#else /* CS_MODE */
int error_code = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
error_code = xlogtb_reset_isolation (thread_p, isolation);
exit_server (*thread_p);
return error_code;
#endif /* !CS_MODE */
}
/*
* log_set_interrupt -
*
* return:
*
* set(in):
*
* NOTE:
*/
void
log_set_interrupt (int set)
{
#if defined(CS_MODE)
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
request = OR_ALIGNED_BUF_START (a_request);
or_pack_int (request, set);
(void) net_client_request_no_reply (NET_SERVER_LOG_SET_INTERRUPT, request, OR_ALIGNED_BUF_SIZE (a_request));
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xlogtb_set_interrupt (thread_p, set);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
/*
* log_checkpoint -
*
* return:
*
* NOTE:
*/
int
log_checkpoint (void)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_LOG_CHECKPOINT, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
/* Cannot run in standalone mode */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_NOT_IN_STANDALONE, 1, "checkpoint");
return ER_NOT_IN_STANDALONE;
#endif /* !CS_MODE */
}
/*
* log_dump_stat -
*
* return:
*
* outfp(in):
*
* NOTE:
*/
void
log_dump_stat (FILE * outfp)
{
#if defined(CS_MODE)
int req_error;
if (outfp == NULL)
{
outfp = stdout;
}
req_error = net_client_request_recv_stream (NET_SERVER_LOG_DUMP_STAT, NULL, 0, NULL, 0, NULL, 0, outfp);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xlogpb_dump_stat (outfp);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
/*
* log_set_suppress_repl_on_transaction -
*
* return:
*
* set(in):
*
* NOTE:
*/
int
log_set_suppress_repl_on_transaction (int set)
{
#if defined(CS_MODE)
int req_error = NO_ERROR;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *request, *reply;
request = OR_ALIGNED_BUF_START (a_request);
or_pack_int (request, set);
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_LOG_SET_SUPPRESS_REPL_ON_TRANSACTION, request,
OR_ALIGNED_BUF_SIZE (a_request), reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error == NO_ERROR)
{
or_unpack_int (reply, &req_error);
}
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xlogtb_set_suppress_repl_on_transaction (thread_p, set);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
#if defined(CS_MODE)
/*
* log_find_lob_locator -
*
* return:
*
* locator(in):
* real_locator(out):
*
* NOTE:
*/
LOB_LOCATOR_STATE
log_find_lob_locator (const char *locator, char *real_locator)
{
LOB_LOCATOR_STATE state = LOB_UNKNOWN;
int req_error, state_int, request_size, strlen;
char *request, *reply, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
int real_loc_size;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (locator, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return LOB_UNKNOWN;
}
(void) pack_const_string_with_length (request, locator, strlen);
req_error =
net_client_request2_no_malloc (NET_SERVER_LOG_FIND_LOB_LOCATOR, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, real_locator, &real_loc_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &real_loc_size);
(void) or_unpack_int (ptr, &state_int);
state = (LOB_LOCATOR_STATE) state_int;
}
free_and_init (request);
return state;
}
/*
* log_add_lob_locator -
*
* return: NO_ERROR or error status
*
* locator(in):
* state(in);
*
* NOTE:
*/
int
log_add_lob_locator (const char *locator, LOB_LOCATOR_STATE state)
{
int req_error, error_code = ER_FAILED, request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (locator, &strlen) + OR_INT_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, locator, strlen);
ptr = or_pack_int (ptr, (int) state);
req_error = net_client_request (NET_SERVER_LOG_ADD_LOB_LOCATOR, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &error_code);
}
free_and_init (request);
return error_code;
}
/*
* log_change_state_of_locator -
*
* return: NO_ERROR or error status
*
* locator(in):
* state(in);
*
* NOTE:
*/
int
log_change_state_of_locator (const char *locator, const char *new_locator, LOB_LOCATOR_STATE state)
{
int req_error, error_code = ER_NET_CLIENT_DATA_RECEIVE;
int request_size, strlen, strlen2;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (locator, &strlen) + length_const_string (new_locator, &strlen2) + OR_INT_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, locator, strlen);
ptr = pack_const_string_with_length (ptr, new_locator, strlen2);
ptr = or_pack_int (ptr, (int) state);
req_error = net_client_request (NET_SERVER_LOG_CHANGE_STATE_OF_LOCATOR, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &error_code);
}
free_and_init (request);
return error_code;
}
/*
* log_drop_lob_locator -
*
* return: NO_ERROR or error status
*
* locator(in):
*
* NOTE:
*/
int
log_drop_lob_locator (const char *locator)
{
int req_error, error_code = ER_NET_CLIENT_DATA_RECEIVE;
int request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (locator, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, locator, strlen);
req_error = net_client_request (NET_SERVER_LOG_DROP_LOB_LOCATOR, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &error_code);
}
free_and_init (request);
return error_code;
}
#endif // CS_MODE
int
log_supplement_statement (int ddl_type, int objtype, OID * classoid, OID * objoid, const char *stmt_text)
{
#if defined(CS_MODE)
int req_error, rep_error = ER_FAILED;
int request_size = 0;
char *request = NULL, *ptr, *start_ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
/* ddl_type, object type, class OID, object OID, statement */
request_size = OR_INT_SIZE + OR_INT_SIZE + OR_OID_SIZE + OR_OID_SIZE + or_packed_string_length (stmt_text, NULL);
request = (char *) malloc (request_size + MAX_ALIGNMENT);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = start_ptr = PTR_ALIGN (request, INT_ALIGNMENT);
ptr = or_pack_int (ptr, ddl_type);
ptr = or_pack_int (ptr, objtype);
ptr = or_pack_oid (ptr, classoid);
ptr = or_pack_oid (ptr, objoid);
ptr = or_pack_string (ptr, stmt_text);
request_size = ptr - start_ptr;
req_error =
net_client_request (NET_SERVER_SUPPLEMENT_STMT, start_ptr, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &rep_error);
}
free_and_init (request);
return rep_error;
#endif // CS_MODE
return ER_NOT_IN_STANDALONE;
}
/*
* tran_server_commit -
*
* return:
*
* retain_lock(in):
*
* NOTE:
*/
TRAN_STATE
tran_server_commit (bool retain_lock)
{
#if defined(CS_MODE)
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
int req_error, tran_state_int, should_conn_reset;
int i = 0;
char *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE /* retain_lock */
+ OR_INT_SIZE /* row_count */
+ OR_INT_SIZE /* count of end query requests */
+ OR_PTR_SIZE * NET_DEFER_END_QUERIES_MAX /* query ids */
+ MAX_ALIGNMENT /* aligmnent */
)a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply;
int row_count = 0;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
/* Pack retain_lock */
ptr = or_pack_int (request, (int) retain_lock);
/* Pack row_count */
row_count = db_get_row_count_cache ();
ptr = or_pack_int (ptr, row_count);
/* Pack query ids to end */
assert (net_Deferred_end_queries_count <= NET_DEFER_END_QUERIES_MAX);
ptr = or_pack_int (ptr, net_Deferred_end_queries_count);
for (i = 0; i < net_Deferred_end_queries_count; i++)
{
ptr = or_pack_ptr (ptr, net_Deferred_end_queries[i]);
}
net_Deferred_end_queries_count = 0;
assert (CAST_BUFLEN (ptr - request) <= (int) OR_ALIGNED_BUF_SIZE (a_request));
req_error =
net_client_request (NET_SERVER_TM_SERVER_COMMIT, request, CAST_BUFLEN (ptr - request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &tran_state_int);
tran_state = (TRAN_STATE) tran_state_int;
ptr = or_unpack_int (ptr, &should_conn_reset);
if (should_conn_reset != 0 && log_does_allow_replication ())
{
/*
* fail-back action
* make the client to reconnect to the active server
*/
db_Connect_status = DB_CONNECTION_STATUS_RESET;
er_log_debug (ARG_FILE_LINE, "tran_server_commit: DB_CONNECTION_STATUS_RESET\n");
}
}
net_cleanup_client_queues ();
return tran_state;
#else /* CS_MODE */
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
THREAD_ENTRY *thread_p = enter_server ();
tran_state = xtran_server_commit (thread_p, retain_lock);
exit_server (*thread_p);
return tran_state;
#endif /* !CS_MODE */
}
/*
* tran_server_abort -
*
* return:
*
* NOTE:
*/
TRAN_STATE
tran_server_abort (void)
{
#if defined(CS_MODE)
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
int req_error, tran_state_int, should_conn_reset;
char *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
/* Queries will be aborted. */
net_Deferred_end_queries_count = 0;
req_error =
net_client_request (NET_SERVER_TM_SERVER_ABORT, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &tran_state_int);
tran_state = (TRAN_STATE) tran_state_int;
ptr = or_unpack_int (ptr, &should_conn_reset);
if (should_conn_reset != 0 && log_does_allow_replication ())
{
/*
* fail-back action
* make the client to reconnect to the active server
*/
db_Connect_status = DB_CONNECTION_STATUS_RESET;
er_log_debug (ARG_FILE_LINE, "tran_server_abort: DB_CONNECTION_STATUS_RESET\n");
}
}
net_cleanup_client_queues ();
return tran_state;
#else /* CS_MODE */
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
THREAD_ENTRY *thread_p = enter_server ();
tran_state = xtran_server_abort (thread_p);
exit_server (*thread_p);
return tran_state;
#endif /* !CS_MODE */
}
const char *
tran_get_tranlist_state_name (TRAN_STATE state)
{
// You should also change the messages:
// MSGCAT_UTIL_SET_TRANLIST.TRANLIST_MSG_QUERY_INFO_ENTRY, MSGCAT_UTIL_SET_TRANLIST.TRANLIST_MSG_FULL_INFO_ENTRY,
// MSGCAT_UTIL_SET_TRANLIST.TRANLIST_MSG_SUMMARY_ENTRY and their headings and underscores,
// when you add a state longer than the current longest, "(COMMITTING)".
switch (state)
{
case TRAN_RECOVERY:
return "(RECOVERY)";
case TRAN_ACTIVE:
return "(ACTIVE)";
case TRAN_UNACTIVE_COMMITTED:
return "(COMMITTED)";
case TRAN_UNACTIVE_WILL_COMMIT:
return "(COMMITTING)";
case TRAN_UNACTIVE_COMMITTED_WITH_POSTPONE:
return "(COMMITTED1)";
case TRAN_UNACTIVE_TOPOPE_COMMITTED_WITH_POSTPONE:
return "(COMMITTED3)";
case TRAN_UNACTIVE_ABORTED:
return "(ABORTED)";
case TRAN_UNACTIVE_UNILATERALLY_ABORTED:
return "(KILLED)";
case TRAN_UNACTIVE_2PC_PREPARE:
return "(2PC1)";
case TRAN_UNACTIVE_2PC_COLLECTING_PARTICIPANT_VOTES:
return "(2PC2)";
case TRAN_UNACTIVE_2PC_ABORT_DECISION:
return "(2PC3)";
case TRAN_UNACTIVE_2PC_COMMIT_DECISION:
return "(2PC4)";
case TRAN_UNACTIVE_COMMITTED_INFORMING_PARTICIPANTS:
return "(COMMITTED5)";
case TRAN_UNACTIVE_ABORTED_INFORMING_PARTICIPANTS:
return "(ABORTED3)";
case TRAN_UNACTIVE_UNKNOWN:
default:
return "(UNKNOWN)";
}
return "(UNKNOWN)";
}
/*
* tran_is_blocked -
*
* return:
*
* tran_index(in):
*
* NOTE:
*/
bool
tran_is_blocked (int tran_index)
{
#if defined(CS_MODE)
bool blocked = false;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
int temp;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, tran_index);
req_error =
net_client_request (NET_SERVER_TM_ISBLOCKED, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &temp);
blocked = (temp == 1) ? true : false;
}
return blocked;
#else /* CS_MODE */
bool blocked = false;
THREAD_ENTRY *thread_p = enter_server ();
blocked = xtran_is_blocked (thread_p, tran_index);
exit_server (*thread_p);
return blocked;
#endif /* !CS_MODE */
}
/*
* tran_server_has_updated -
*
* return:
*
* NOTE:
*/
int
tran_server_has_updated (void)
{
#if defined(CS_MODE)
int has_updated = 0; /* TODO */
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TM_SERVER_HAS_UPDATED, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply),
NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &has_updated);
}
return has_updated;
#else /* CS_MODE */
int has_updated = 0; /* TODO */
THREAD_ENTRY *thread_p = enter_server ();
has_updated = xtran_server_has_updated (thread_p);
exit_server (*thread_p);
return has_updated;
#endif /* !CS_MODE */
}
/*
* tran_server_is_active_and_has_updated -
*
* return:
*
* NOTE:
*/
int
tran_server_is_active_and_has_updated (void)
{
#if defined(CS_MODE)
int isactive_and_has_updated = 0; /* TODO */
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TM_SERVER_ISACTIVE_AND_HAS_UPDATED, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &isactive_and_has_updated);
}
return isactive_and_has_updated;
#else /* CS_MODE */
int isactive_and_has_updated = 0; /* TODO */
if (!BO_IS_SERVER_RESTARTED ())
{
// server is killed already
return 0;
}
THREAD_ENTRY *thread_p = enter_server ();
isactive_and_has_updated = xtran_server_is_active_and_has_updated (thread_p);
exit_server (*thread_p);
return (isactive_and_has_updated);
#endif /* !CS_MODE */
}
/*
* tran_wait_server_active_trans -
*
* return:
*
* NOTE:
*/
int
tran_wait_server_active_trans (void)
{
#if defined(CS_MODE)
int status = 0;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TM_WAIT_SERVER_ACTIVE_TRANS, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
return status;
#else /* CS_MODE */
return 0;
#endif /* !CS_MODE */
}
/*
* tran_server_set_global_tran_info -
*
* return:
*
* gtrid(in):
* info(in):
* size(in):
*
* NOTE:
*/
int
tran_server_set_global_tran_info (int gtrid, void *info, int size)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
or_pack_int (request, gtrid);
req_error =
net_client_request (NET_SERVER_TM_SERVER_SET_GTRINFO, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), (char *) info, size, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &success);
}
return success;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xtran_server_set_global_tran_info (thread_p, gtrid, info, size);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* tran_server_get_global_tran_info -
*
* return:
*
* gtrid(in):
* buffer(in):
* size(in):
*
* NOTE:
*/
int
tran_server_get_global_tran_info (int gtrid, void *buffer, int size)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply, *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_int (request, gtrid);
ptr = or_pack_int (ptr, size);
req_error =
net_client_request2_no_malloc (NET_SERVER_TM_SERVER_GET_GTRINFO, request,
OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), (char *) buffer, size, (char *) buffer, &size);
if (!req_error)
{
ptr = or_unpack_int (reply, &size);
ptr = or_unpack_int (ptr, &success);
}
return success;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xtran_server_get_global_tran_info (thread_p, gtrid, buffer, size);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* tran_server_2pc_start -
*
* return:
*
* NOTE:
*/
int
tran_server_2pc_start (void)
{
#if defined(CS_MODE)
int gtrid = NULL_TRANID;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TM_SERVER_2PC_START, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply),
NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, >rid);
}
return gtrid;
#else /* CS_MODE */
int gtrid = NULL_TRANID;
THREAD_ENTRY *thread_p = enter_server ();
gtrid = xtran_server_2pc_start (thread_p);
exit_server (*thread_p);
return gtrid;
#endif /* !CS_MODE */
}
/*
* tran_server_2pc_prepare -
*
* return:
*
* NOTE:
*/
TRAN_STATE
tran_server_2pc_prepare (void)
{
#if defined(CS_MODE)
TRAN_STATE state = TRAN_UNACTIVE_UNKNOWN;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TM_SERVER_2PC_PREPARE, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply),
NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, (int *) &state);
}
return state;
#else /* CS_MODE */
TRAN_STATE state = TRAN_UNACTIVE_UNKNOWN;
THREAD_ENTRY *thread_p = enter_server ();
state = xtran_server_2pc_prepare (thread_p);
exit_server (*thread_p);
return (state);
#endif /* !CS_MODE */
}
/*
* tran_server_2pc_recovery_prepared -
*
* return:
*
* gtrids(in):
* size(in):
*
* NOTE:
*/
int
tran_server_2pc_recovery_prepared (int gtrids[], int size)
{
#if defined(CS_MODE)
int count = -1, i;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
int reply_size;
char *reply, *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply_size = OR_INT_SIZE + (OR_INT_SIZE * size);
reply = (char *) malloc (reply_size);
if (reply == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) reply_size);
return -1;
}
or_pack_int (request, size);
req_error =
net_client_request (NET_SERVER_TM_SERVER_2PC_RECOVERY_PREPARED, request,
OR_ALIGNED_BUF_SIZE (a_request), reply, reply_size, NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &count);
for (i = 0; i < count && i < size; i++)
{
ptr = or_unpack_int (ptr, >rids[i]);
}
}
free_and_init (reply);
return count;
#else /* CS_MODE */
int count;
THREAD_ENTRY *thread_p = enter_server ();
count = xtran_server_2pc_recovery_prepared (thread_p, gtrids, size);
exit_server (*thread_p);
return count;
#endif /* !CS_MODE */
}
/*
* tran_server_2pc_attach_global_tran -
*
* return:
*
* gtrid(in):
*
* NOTE:
*/
int
tran_server_2pc_attach_global_tran (int gtrid)
{
#if defined(CS_MODE)
int tran_index = NULL_TRAN_INDEX;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
or_pack_int (request, gtrid);
req_error =
net_client_request (NET_SERVER_TM_SERVER_2PC_ATTACH_GT, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &tran_index);
}
return tran_index;
#else /* CS_MODE */
int tran_index = NULL_TRAN_INDEX;
THREAD_ENTRY *thread_p = enter_server ();
tran_index = xtran_server_2pc_attach_global_tran (thread_p, gtrid);
exit_server (*thread_p);
return tran_index;
#endif /* !CS_MODE */
}
/*
* tran_server_2pc_prepare_global_tran -
*
* return:
*
* gtrid(in):
*
* NOTE:
*/
TRAN_STATE
tran_server_2pc_prepare_global_tran (int gtrid)
{
#if defined(CS_MODE)
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
int req_error, tran_state_int;
char *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
or_pack_int (request, gtrid);
req_error =
net_client_request (NET_SERVER_TM_SERVER_2PC_PREPARE_GT, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &tran_state_int);
tran_state = (TRAN_STATE) tran_state_int;
}
return tran_state;
#else /* CS_MODE */
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
THREAD_ENTRY *thread_p = enter_server ();
tran_state = xtran_server_2pc_prepare_global_tran (thread_p, gtrid);
exit_server (*thread_p);
return tran_state;
#endif /* !CS_MODE */
}
#if defined (ENABLE_UNUSED_FUNCTION)
/*
* tran_server_start_topop -
*
* return:
*
* topop_lsa(in):
*
* NOTE:
*/
int
tran_server_start_topop (LOG_LSA * topop_lsa)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_LOG_LSA_ALIGNED_SIZE) a_reply;
char *reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TM_SERVER_START_TOPOP, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL,
0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
ptr = or_unpack_log_lsa (ptr, topop_lsa);
}
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
if (xtran_server_start_topop (thread_p, topop_lsa) != NO_ERROR)
{
success = ER_FAILED;
}
else
{
success = NO_ERROR;
}
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* tran_server_end_topop -
*
* return:
*
* result(in):
* topop_lsa(in):
*
* NOTE:
*/
TRAN_STATE
tran_server_end_topop (LOG_RESULT_TOPOP result, LOG_LSA * topop_lsa)
{
#if defined(CS_MODE)
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
int req_error, tran_state_int;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_LOG_LSA_ALIGNED_SIZE) a_reply;
char *reply;
char *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_int (request, (int) result);
req_error =
net_client_request (NET_SERVER_TM_SERVER_END_TOPOP, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL,
0);
if (!req_error)
{
ptr = or_unpack_int (reply, &tran_state_int);
tran_state = (TRAN_STATE) tran_state_int;
ptr = or_unpack_log_lsa (ptr, topop_lsa);
}
return tran_state;
#else /* CS_MODE */
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
THREAD_ENTRY *thread_p = enter_server ();
tran_state = xtran_server_end_topop (thread_p, result, topop_lsa);
exit_server (*thread_p);
return (tran_state);
#endif /* !CS_MODE */
}
#endif
/*
* tran_server_savepoint -
*
* return:
*
* savept_name(in):
* savept_lsa(in):
*
* NOTE:
*/
int
tran_server_savepoint (const char *savept_name, LOG_LSA * savept_lsa)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error, request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_LOG_LSA_ALIGNED_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (savept_name, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = pack_const_string_with_length (request, savept_name, strlen);
req_error = net_client_request (NET_SERVER_TM_SERVER_SAVEPOINT, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
ptr = or_unpack_log_lsa (ptr, savept_lsa);
}
free_and_init (request);
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xtran_server_savepoint (thread_p, savept_name, savept_lsa);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* tran_server_partial_abort -
*
* return:
*
* savept_name(in):
* savept_lsa(in):
*
* NOTE:
*/
TRAN_STATE
tran_server_partial_abort (const char *savept_name, LOG_LSA * savept_lsa)
{
#if defined(CS_MODE)
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
int req_error, tran_state_int, request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_LOG_LSA_ALIGNED_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (savept_name, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return TRAN_UNACTIVE_UNKNOWN;
}
ptr = pack_const_string_with_length (request, savept_name, strlen);
req_error = net_client_request (NET_SERVER_TM_SERVER_PARTIAL_ABORT, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &tran_state_int);
tran_state = (TRAN_STATE) tran_state_int;
ptr = or_unpack_log_lsa (ptr, savept_lsa);
}
free_and_init (request);
return tran_state;
#else /* CS_MODE */
TRAN_STATE tran_state = TRAN_UNACTIVE_UNKNOWN;
THREAD_ENTRY *thread_p = enter_server ();
tran_state = xtran_server_partial_abort (thread_p, savept_name, savept_lsa);
exit_server (*thread_p);
return tran_state;
#endif /* !CS_MODE */
}
/*
* acl_reload -
*
* return:
*
*/
int
acl_reload ()
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_ACL_RELOAD, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_errcode (reply, &error);
}
return error;
#else
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* acl_dump -
*
* return:
*
* outfp(in):
*/
void
acl_dump (FILE * outfp)
{
#if defined(CS_MODE)
int req_error;
if (outfp == NULL)
{
outfp = stdout;
}
req_error = net_client_request_recv_stream (NET_SERVER_ACL_DUMP, NULL, 0, NULL, 0, NULL, 0, outfp);
#endif /* !CS_MODE */
}
/*
* lock_dump -
*
* return:
*
* outfp(in):
*/
void
lock_dump (FILE * outfp, int is_contention)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request, *ptr;
if (outfp == NULL)
{
outfp = stdout;
}
request = OR_ALIGNED_BUF_START (a_request);
(void) or_pack_int (request, is_contention);
req_error =
net_client_request_recv_stream (NET_SERVER_LK_DUMP, request, OR_ALIGNED_BUF_SIZE (a_request), NULL,
0, NULL, 0, outfp);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xlock_dump (thread_p, outfp, is_contention);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
/*
* boot_initialize_server -
*
* return:
*
* print_version(in):
* db_overwrite(in):
* db_desired_pagesize(in):
* db_name(in):
* db_path(in):
* vol_path(in):
* db_comments(in):
* db_npages(in):
* file_addmore_vols(in):
* db_server_host(in):
* log_path(in):
* log_npages(in):
* rootclass_oid(in):
* rootclass_hfid(in):
* client_prog_name(in):
* client_user_name(in):
* client_host_name(in):
* client_process_id(in):
* client_lock_wait(in):
* client_isolation(in):
*
* NOTE:
*/
int
boot_initialize_server (const BOOT_CLIENT_CREDENTIAL * client_credential, BOOT_DB_PATH_INFO * db_path_info,
bool db_overwrite, const char *file_addmore_vols, DKNPAGES db_npages,
PGLENGTH db_desired_pagesize, DKNPAGES log_npages, PGLENGTH db_desired_log_page_size,
OID * rootclass_oid, HFID * rootclass_hfid, int client_lock_wait,
TRAN_ISOLATION client_isolation)
{
#if defined(CS_MODE)
/* Should not called in CS_MODE */
assert (0);
return NULL_TRAN_INDEX;
#else /* CS_MODE */
int tran_index = NULL_TRAN_INDEX;
enter_server_no_thread_entry ();
tran_index =
xboot_initialize_server (client_credential, db_path_info, db_overwrite, file_addmore_vols, db_npages,
db_desired_pagesize, log_npages, db_desired_log_page_size, rootclass_oid, rootclass_hfid,
client_lock_wait, client_isolation);
exit_server_no_thread_entry ();
return (tran_index);
#endif /* !CS_MODE */
}
/*
* boot_register_client -
*
* return:
*
* client_credential(in)
* client_lock_wait(in):
* client_isolation(in):
* tran_state(out):
* server_credential(out):
*/
int
boot_register_client (BOOT_CLIENT_CREDENTIAL * client_credential, int client_lock_wait, TRAN_ISOLATION client_isolation,
TRAN_STATE * tran_state, BOOT_SERVER_CREDENTIAL * server_credential)
{
#if defined(CS_MODE)
int tran_index = NULL_TRAN_INDEX;
int area_size, req_error, temp_int;
char *reply, *area, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
reply = OR_ALIGNED_BUF_START (a_reply);
packing_packer packer;
cubmem::extensible_block ext_blk;
int clisol_toint = (int) client_isolation;
packer.set_buffer_and_pack_all (ext_blk, *client_credential, client_lock_wait, clisol_toint);
req_error =
net_client_request2 (NET_SERVER_BO_REGISTER_CLIENT, ext_blk.get_ptr (),
(int) packer.get_current_size (), reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL,
0, &area, &area_size);
if (!req_error)
{
or_unpack_int (reply, &area_size);
if (area_size > 0)
{
int ha_state_to_int;
ptr = or_unpack_int (area, &tran_index);
ptr = or_unpack_int (ptr, &temp_int);
*tran_state = (TRAN_STATE) temp_int;
ptr = or_unpack_string (ptr, &server_credential->db_full_name);
ptr = or_unpack_string (ptr, &server_credential->host_name);
ptr = or_unpack_string (ptr, &server_credential->lob_path);
ptr = or_unpack_int (ptr, &server_credential->process_id);
ptr = or_unpack_oid (ptr, &server_credential->root_class_oid);
ptr = or_unpack_hfid (ptr, &server_credential->root_class_hfid);
ptr = or_unpack_int (ptr, &temp_int);
server_credential->page_size = (PGLENGTH) temp_int;
ptr = or_unpack_int (ptr, &temp_int);
server_credential->log_page_size = (PGLENGTH) temp_int;
ptr = or_unpack_float (ptr, &server_credential->disk_compatibility);
ptr = or_unpack_int (ptr, &ha_state_to_int);
server_credential->ha_server_state = (HA_SERVER_STATE) ha_state_to_int;
ptr = or_unpack_int (ptr, &server_credential->db_charset);
ptr = or_unpack_string (ptr, &server_credential->db_lang);
}
free_and_init (area);
}
return tran_index;
#else /* CS_MODE */
int tran_index = NULL_TRAN_INDEX;
enter_server_no_thread_entry ();
tran_index =
xboot_register_client (NULL, client_credential, client_lock_wait, client_isolation, tran_state, server_credential);
exit_server_no_thread_entry ();
return tran_index;
#endif /* !CS_MODE */
}
/*
* boot_unregister_client -
*
* return:
*
* tran_index(in):
*
* NOTE:
*/
int
boot_unregister_client (int tran_index)
{
#if defined(CS_MODE)
int error_code = ER_FAILED;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, tran_index);
req_error =
net_client_request (NET_SERVER_BO_UNREGISTER_CLIENT, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error == NO_ERROR)
{
or_unpack_int (reply, &error_code);
}
else
{
error_code = req_error;
}
return error_code;
#else /* CS_MODE */
int error_code = NO_ERROR;
if (!BO_IS_SERVER_RESTARTED ())
{
// server is killed already
return NO_ERROR;
}
THREAD_ENTRY *thread_p = enter_server ();
error_code = xboot_unregister_client (thread_p, tran_index);
if (tran_index == NULL_TRAN_INDEX)
{
assert (thread_p == NULL);
exit_server_no_thread_entry ();
}
else
{
exit_server (*thread_p);
}
return error_code;
#endif /* !CS_MODE */
}
/*
* boot_backup -
*
* return:
*
* backup_path(in):
* backup_level(in):
* delete_unneeded_logarchives(in):
* backup_verbose_file(in):
* num_threads(in):
* zip_method(in):
* zip_level(in):
* skip_activelog(in):
* sleep_msecs(in):
*
* NOTE:
*/
int
boot_backup (const char *backup_path, FILEIO_BACKUP_LEVEL backup_level, bool delete_unneeded_logarchives,
const char *backup_verbose_file, int num_threads, FILEIO_ZIP_METHOD zip_method, FILEIO_ZIP_LEVEL zip_level,
int skip_activelog, int sleep_msecs, bool separate_keys)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int request_size, strlen1, strlen2;
char *request, *ptr;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE * 3) a_reply;
char *reply;
char *rd1, *rd2;
int d1, d2;
int cb_type;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = (length_const_string (backup_path, &strlen1) + OR_INT_SIZE + OR_INT_SIZE
+ length_const_string (backup_verbose_file, &strlen2) + OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE
+ OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = pack_const_string_with_length (request, backup_path, strlen1);
ptr = or_pack_int (ptr, backup_level);
ptr = or_pack_int (ptr, delete_unneeded_logarchives ? 1 : 0);
ptr = pack_const_string_with_length (ptr, backup_verbose_file, strlen2);
ptr = or_pack_int (ptr, num_threads);
ptr = or_pack_int (ptr, zip_method);
ptr = or_pack_int (ptr, zip_level);
ptr = or_pack_int (ptr, skip_activelog);
ptr = or_pack_int (ptr, sleep_msecs);
ptr = or_pack_int (ptr, separate_keys);
req_error =
net_client_request_with_callback (NET_SERVER_BO_BACKUP, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0, &rd1, &d1, &rd2,
&d2, NULL, NULL);
if (!req_error)
{
ptr = or_unpack_int (reply, &cb_type);
or_unpack_int (ptr, &success);
/* we just ignore the last part of the reply */
}
free_and_init (request);
return success;
#else /* CS_MODE */
int success = false;
THREAD_ENTRY *thread_p = enter_server ();
success = xboot_backup (thread_p, backup_path, backup_level, delete_unneeded_logarchives, backup_verbose_file,
num_threads, zip_method, zip_level, skip_activelog, sleep_msecs, separate_keys);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* boot_add_volume_extension -
*
* return:
*
* ext_info(in):
*
* NOTE:
*/
VOLID
boot_add_volume_extension (DBDEF_VOL_EXT_INFO * ext_info)
{
#if defined(CS_MODE)
int int_volid;
VOLID volid = NULL_VOLID;
int request_size, strlen1, strlen2, strlen3;
char *request, *ptr;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = (length_const_string (ext_info->path, &strlen1)
+ length_const_string (ext_info->name, &strlen2)
+ length_const_string (ext_info->comments, &strlen3)
+ OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return NULL_VOLID;
}
ptr = pack_const_string_with_length (request, ext_info->path, strlen1);
ptr = pack_const_string_with_length (ptr, ext_info->name, strlen2);
ptr = pack_const_string_with_length (ptr, ext_info->comments, strlen3);
ptr = or_pack_int (ptr, (int) ext_info->max_npages);
ptr = or_pack_int (ptr, (int) ext_info->max_writesize_in_sec);
ptr = or_pack_int (ptr, (int) ext_info->purpose);
ptr = or_pack_int (ptr, (int) ext_info->overwrite);
ptr = or_pack_int (ptr, (int) ext_info->voltype);
req_error = net_client_request (NET_SERVER_BO_ADD_VOLEXT, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &int_volid);
volid = int_volid;
}
free_and_init (request);
return volid;
#else /* CS_MODE */
VOLID volid;
THREAD_ENTRY *thread_p = enter_server ();
volid = xboot_add_volume_extension (thread_p, ext_info);
exit_server (*thread_p);
return volid;
#endif /* !CS_MODE */
}
/*
* boot_check_db_consistency -
*
* return:
*
* check_flag(in):
*
* NOTE:
*/
int
boot_check_db_consistency (int check_flag, OID * oids, int num_oids, BTID * index_btid)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int req_error;
int cb_type;
char *rd1, *rd2;
int d1, d2;
OR_ALIGNED_BUF (OR_INT_SIZE * 3) a_reply;
char *reply;
char *request, *ptr;
size_t request_size;
int i;
request_size = OR_INT_SIZE; /* check_flag */
request_size += OR_INT_SIZE; /* num_oid */
request_size += (OR_OID_SIZE * num_oids);
request_size += OR_BTID_ALIGNED_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = or_pack_int (request, check_flag);
ptr = or_pack_int (ptr, num_oids);
for (i = 0; i < num_oids; i++)
{
ptr = or_pack_oid (ptr, &oids[i]);
}
ptr = or_pack_btid (ptr, index_btid);
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request_with_callback (NET_SERVER_BO_CHECK_DBCONSISTENCY, request, (int) request_size,
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0, &rd1, &d1,
&rd2, &d2, NULL, NULL);
free_and_init (request);
if (!req_error)
{
ptr = or_unpack_int (reply, &cb_type);
or_unpack_int (ptr, &success);
}
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xboot_check_db_consistency (thread_p, check_flag, oids, num_oids, index_btid);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* boot_find_number_permanent_volumes -
*
* return:
*
* NOTE:
*/
int
boot_find_number_permanent_volumes (void)
{
#if defined(CS_MODE)
int nvols = -1;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_BO_FIND_NPERM_VOLS, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &nvols);
}
return nvols;
#else /* CS_MODE */
int nvols = -1;
THREAD_ENTRY *thread_p = enter_server ();
nvols = xboot_find_number_permanent_volumes (thread_p);
exit_server (*thread_p);
return nvols;
#endif /* !CS_MODE */
}
/*
* boot_find_number_temp_volumes -
*
* return:
*
* NOTE:
*/
int
boot_find_number_temp_volumes (void)
{
#if defined(CS_MODE)
int nvols = -1;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_BO_FIND_NTEMP_VOLS, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &nvols);
}
return nvols;
#else /* CS_MODE */
int nvols = -1;
THREAD_ENTRY *thread_p = enter_server ();
nvols = xboot_find_number_temp_volumes (thread_p);
exit_server (*thread_p);
return nvols;
#endif /* !CS_MODE */
}
/*
* boot_find_last_permanant -
*
* return:
*
* NOTE:
*/
VOLID
boot_find_last_permanent (void)
{
VOLID volid = NULL_VOLID;
#if defined(CS_MODE)
int int_volid;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_BO_FIND_LAST_PERM, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &int_volid);
volid = (VOLID) int_volid;
}
return volid;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
volid = xboot_find_last_permanent (thread_p);
exit_server (*thread_p);
return volid;
#endif /* !CS_MODE */
}
/*
* boot_find_last_temp -
*
* return:
*
* NOTE:
*/
int
boot_find_last_temp (void)
{
#if defined(CS_MODE)
int nvols = -1;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_BO_FIND_LAST_TEMP, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &nvols);
}
return nvols;
#else /* CS_MODE */
int nvols = -1;
THREAD_ENTRY *thread_p = enter_server ();
nvols = xboot_find_last_temp (thread_p);
exit_server (*thread_p);
return nvols;
#endif /* !CS_MODE */
}
/*
* boot_delete -
*
* return:
*
* NOTE:
*/
int
boot_delete (const char *db_name, bool force_delete)
{
#if defined(CS_MODE)
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ONLY_IN_STANDALONE, 1, "delete database");
return ER_FAILED;
#else /* CS_MODE */
int error_code;
enter_server_no_thread_entry ();
error_code = xboot_delete (db_name, force_delete, BOOT_SHUTDOWN_EXCEPT_COMMON_MODULES);
exit_server_no_thread_entry ();
return error_code;
#endif /* !CS_MODE */
}
#if defined (SA_MODE)
/*
* boot_restart_from_backup -
*
* return:
*
* NOTE:
*/
int
boot_restart_from_backup (int print_restart, const char *db_name, bo_restart_arg * r_args)
{
int tran_index;
enter_server_no_thread_entry ();
tran_index = xboot_restart_from_backup (NULL, print_restart, db_name, r_args);
exit_server_no_thread_entry ();
return tran_index;
}
#endif /* SA_MODE */
/*
* boot_shutdown_server -
*
* return:
*
* NOTE:
*/
bool
boot_shutdown_server (ER_FINAL_CODE iserfinal)
{
#if defined(CS_MODE)
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ONLY_IN_STANDALONE, 1, "");
return false;
#else /* CS_MODE */
bool result;
THREAD_ENTRY *thread_p = enter_server ();
result = xboot_shutdown_server (thread_p, iserfinal);
assert (thread_p == NULL);
exit_server_no_thread_entry ();
return result;
#endif /* !CS_MODE */
}
/*
* csession_find_or_create_session - check if session is still active
* if not, create a new session
*
* return : error code or NO_ERROR
* session_id (in/out) : the id of the session to end
* row_count (out) : the value of row count for this session
* server_session_key (in/out) :
*/
int
csession_find_or_create_session (SESSION_ID * session_id, int *row_count, char *server_session_key, const char *db_user,
const char *host, const char *program_name)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply = NULL;
char *request = NULL, *area = NULL;
char *ptr;
int request_size, area_size;
int db_user_len, host_len, program_name_len;
SESSION_PARAM *session_params = NULL;
int error = NO_ERROR, update_parameter_values = 0;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = OR_INT_SIZE; /* session_id */
request_size += or_packed_stream_length (SERVER_SESSION_KEY_SIZE);
request_size += sysprm_packed_session_parameters_length (cached_session_parameters, request_size);
request_size += length_const_string (db_user, &db_user_len);
request_size += length_const_string (host, &host_len);
request_size += length_const_string (program_name, &program_name_len);
reply = OR_ALIGNED_BUF_START (a_reply);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = or_pack_int (request, ((int) *session_id));
ptr = or_pack_stream (ptr, server_session_key, SERVER_SESSION_KEY_SIZE);
ptr = sysprm_pack_session_parameters (ptr, cached_session_parameters);
ptr = pack_const_string_with_length (ptr, db_user, db_user_len);
ptr = pack_const_string_with_length (ptr, host, host_len);
ptr = pack_const_string_with_length (ptr, program_name, program_name_len);
req_error =
net_client_request2 (NET_SERVER_SES_CHECK_SESSION, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (req_error == NO_ERROR)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error);
if (error != NO_ERROR)
{
free_and_init (request);
return error;
}
if (area_size > 0)
{
ptr = or_unpack_int (area, (int *) session_id);
ptr = or_unpack_int (ptr, row_count);
ptr = or_unpack_stream (ptr, server_session_key, SERVER_SESSION_KEY_SIZE);
ptr = or_unpack_int (ptr, &update_parameter_values);
if (update_parameter_values)
{
ptr = sysprm_unpack_session_parameters (ptr, &session_params);
}
free_and_init (area);
}
if (update_parameter_values)
{
/* session parameters were found in session state and must update parameter values */
if (session_params == NULL)
{
assert (er_errid () != NO_ERROR);
error = er_errid ();
if (error == NO_ERROR)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_GENERIC_ERROR, 0);
error = ER_FAILED;
}
free_and_init (request);
return error;
}
sysprm_update_client_session_parameters (session_params);
}
else
{
/* use the values stored in cached_session_parameters */
sysprm_update_client_session_parameters (cached_session_parameters);
}
sysprm_free_session_parameters (&session_params);
}
free_and_init (request);
return req_error;
#else
int result = NO_ERROR;
SESSION_ID id;
THREAD_ENTRY *thread_p = enter_server ();
if (db_Session_id == DB_EMPTY_SESSION)
{
result = xsession_create_new (thread_p, &id);
}
else
{
id = db_Session_id;
if (xsession_check_session (thread_p, id) != NO_ERROR)
{
/* create new session */
if (xsession_create_new (thread_p, &id) != NO_ERROR)
{
result = ER_FAILED;
}
}
}
db_Session_id = id;
*session_id = db_Session_id;
/* get row count */
if (result != ER_FAILED)
{
xsession_get_row_count (thread_p, row_count);
}
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_end_session - end the session identified by session_id
*
* return : error code or NO_ERROR
* session_id (in) : the id of the session to end
*/
int
csession_end_session (SESSION_ID session_id, bool is_keep_session)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_request;
char *request;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request = OR_ALIGNED_BUF_START (a_request);
ptr = or_pack_int (request, session_id);
ptr = or_pack_int (ptr, is_keep_session);
req_error =
net_client_request (NET_SERVER_SES_END_SESSION, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error != NO_ERROR)
{
return ER_FAILED;
}
return req_error;
#else
int result = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
result = xsession_end_session (thread_p, session_id, is_keep_session);
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_set_row_count - set affected rows count for the current
* session
* return : error code or NO_ERROR
* rows (in) : the count of affected rows
* NOTE : the affected rows count is the number of rows affected by the last
* INSERT, UPDATE or DELETE statement
*/
int
csession_set_row_count (int rows)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request = OR_ALIGNED_BUF_START (a_request);
ptr = or_pack_int (request, rows);
req_error =
net_client_request (NET_SERVER_SES_SET_ROW_COUNT, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error != NO_ERROR)
{
return ER_FAILED;
}
or_unpack_int (reply, &req_error);
return req_error;
#else
int result = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
result = xsession_set_row_count (thread_p, rows);
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_get_row_count - get affected rows count for the current
* session
* return : error code or NO_ERROR
* rows (out): the count of affected rows
* NOTE : the affected rows count is the number of rows affected by the last
* INSERT, UPDATE or DELETE statement
*/
int
csession_get_row_count (int *rows)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
reply = OR_ALIGNED_BUF_START (a_reply);
request = OR_ALIGNED_BUF_START (a_request);
req_error =
net_client_request (NET_SERVER_SES_GET_ROW_COUNT, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error != NO_ERROR)
{
return ER_FAILED;
}
or_unpack_int (reply, &req_error);
or_unpack_int (reply, rows);
return NO_ERROR;
#else
int result = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
result = xsession_get_row_count (thread_p, rows);
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_get_last_insert_id - get the value of the last update serial
* return : error code or NO_ERROR
* value (out) : the value of the last insert id
* update_last_insert_id(in): whether update the last insert id
*/
int
csession_get_last_insert_id (DB_VALUE * value, bool update_last_insert_id)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
char *ptr = NULL;
char *data_reply = NULL;
int data_size = 0;
db_make_null (value);
reply = OR_ALIGNED_BUF_START (a_reply);
request = OR_ALIGNED_BUF_START (a_request);
ptr = or_pack_int (request, update_last_insert_id);
req_error =
net_client_request2 (NET_SERVER_SES_GET_LAST_INSERT_ID, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &data_reply, &data_size);
if (req_error != NO_ERROR)
{
db_make_null (value);
req_error = ER_FAILED;
goto cleanup;
}
/* data_size */
ptr = or_unpack_int (reply, &req_error);
/* req_error */
ptr = or_unpack_int (ptr, &req_error);
if (req_error != NO_ERROR || data_size == 0)
{
req_error = (req_error != NO_ERROR) ? req_error : ER_FAILED;
goto cleanup;
}
or_unpack_value (data_reply, value);
cleanup:
if (data_reply != NULL)
{
free_and_init (data_reply);
}
return req_error;
#else
int result = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
result = xsession_get_last_insert_id (thread_p, value, update_last_insert_id);
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_reset_cur_insert_id - reset cur insert id as NULL
* return : error code or NO_ERROR
*/
int
csession_reset_cur_insert_id (void)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_SES_RESET_CUR_INSERT_ID, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error != NO_ERROR)
{
return ER_FAILED;
}
or_unpack_int (reply, &req_error);
return req_error;
#else
int result = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
result = xsession_reset_cur_insert_id (thread_p);
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_create_prepared_statement () - create a prepared session statement
* return : error code or NO_ERROR
* name (in) : the name of the prepared statement
* alias_print(in): the compiled statement string
* stmt_info (in) : serialized prepared statement information
* info_length(in): the size of the serialized buffer
*/
int
csession_create_prepared_statement (const char *name, const char *alias_print, char *stmt_info, int info_length)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *request = NULL;
char *reply = NULL;
char *ptr = NULL;
int req_size = 0, name_len = 0, alias_print_len = 0;
SHA1Hash alias_sha1 = SHA1_HASH_INITIALIZER;
reply = OR_ALIGNED_BUF_START (a_reply);
req_size = 0;
/* packed size for name */
req_size += length_const_string (name, &name_len);
/* packed size for alias_print */
req_size += length_const_string (alias_print, &alias_print_len);
/* data_size */
req_size += OR_INT_SIZE;
if (alias_print != NULL)
{
/* sha1 */
req_size += OR_SHA1_SIZE;
}
request = (char *) malloc (req_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_size);
req_error = ER_FAILED;
goto cleanup;
}
/* name */
ptr = pack_const_string_with_length (request, name, name_len);
/* alias_print */
ptr = pack_const_string_with_length (ptr, alias_print, alias_print_len);
/* data size */
ptr = or_pack_int (ptr, info_length);
if (alias_print)
{
req_error = SHA1Compute ((const unsigned char *) alias_print, (unsigned) strlen (alias_print), &alias_sha1);
if (req_error != NO_ERROR)
{
ASSERT_ERROR ();
goto cleanup;
}
ptr = or_pack_sha1 (ptr, &alias_sha1);
}
req_error =
net_client_request (NET_SERVER_SES_CREATE_PREPARED_STATEMENT, request, req_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), stmt_info, info_length, NULL, 0);
if (req_error != NO_ERROR)
{
goto cleanup;
}
ptr = or_unpack_int (reply, &req_error);
cleanup:
if (request != NULL)
{
free_and_init (request);
}
return req_error;
#else
int result = NO_ERROR;
char *local_name = NULL;
char *local_alias_print = NULL;
char *local_stmt_info = NULL;
size_t len = 0;
SHA1Hash alias_sha1 = SHA1_HASH_INITIALIZER;
THREAD_ENTRY *thread_p = enter_server ();
/* The server keeps a packed version of the prepared statement information and we need to pack it here */
/* copy name */
if (name != NULL)
{
len = strlen (name);
local_name = (char *) malloc (len + 1);
if (local_name == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, len + 1);
result = ER_FAILED;
goto error;
}
memcpy (local_name, name, len);
local_name[len] = 0;
}
/* copy alias print */
if (alias_print != NULL)
{
len = strlen (alias_print);
local_alias_print = (char *) malloc (len + 1);
if (local_alias_print == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, len + 1);
result = ER_FAILED;
goto error;
}
memcpy (local_alias_print, alias_print, len);
local_alias_print[len] = 0;
result = SHA1Compute ((const unsigned char *) alias_print, (unsigned) strlen (alias_print), &alias_sha1);
if (result != NO_ERROR)
{
ASSERT_ERROR ();
goto error;
}
}
/* copy stmt_info */
if (stmt_info != NULL)
{
local_stmt_info = (char *) malloc (info_length);
if (local_stmt_info == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) info_length);
result = ER_FAILED;
goto error;
}
memcpy (local_stmt_info, stmt_info, info_length);
}
result =
xsession_create_prepared_statement (thread_p, local_name, local_alias_print, &alias_sha1, local_stmt_info,
info_length);
if (result != NO_ERROR)
{
goto error;
}
exit_server (*thread_p);
return result;
error:
if (local_name != NULL)
{
free_and_init (local_name);
}
if (local_alias_print != NULL)
{
free_and_init (local_alias_print);
}
if (local_stmt_info != NULL)
{
free_and_init (local_stmt_info);
}
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_get_prepared_statement () - get information about a prepared session statement
* return : error code or no error
* name (in) : the name of the prepared statement
* xasl_id (out) : XASL id
* stmt_info (out) : serialized prepared statement information
* xasl_header_p (out) : if pointer is not null, request XASL node header along with XASL_ID.
*/
int
csession_get_prepared_statement (const char *name, XASL_ID * xasl_id, char **stmt_info,
xasl_node_header * xasl_header_p)
{
#if defined (CS_MODE)
int req_error = NO_ERROR;
OR_ALIGNED_BUF (OR_INT_SIZE * 2 + OR_XASL_ID_SIZE) a_reply;
char *reply = NULL;
char *reply_data = NULL;
char *request = NULL;
char *ptr = NULL;
int req_size = 0, len = 0;
int reply_size = 0;
int get_xasl_header = xasl_header_p != NULL;
INIT_XASL_NODE_HEADER (xasl_header_p);
req_size = (or_packed_string_length (name, &len) /* name */
+ OR_INT_SIZE /* get_xasl_header */ );
request = (char *) malloc (req_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_size);
req_error = ER_OUT_OF_VIRTUAL_MEMORY;
goto error;
}
ptr = or_pack_string_with_length (request, name, len);
ptr = or_pack_int (ptr, get_xasl_header);
req_error =
net_client_request2 (NET_SERVER_SES_GET_PREPARED_STATEMENT, request, req_size,
OR_ALIGNED_BUF_START (a_reply), OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0,
&reply_data, &reply_size);
if (req_error != NO_ERROR)
{
goto error;
}
reply = OR_ALIGNED_BUF_START (a_reply);
/* unpack reply_size */
ptr = or_unpack_int (reply, &req_error);
/* unpack error code */
ptr = or_unpack_int (ptr, &req_error);
if (req_error != NO_ERROR)
{
/* there was an error fetching session data */
goto error;
}
OR_UNPACK_XASL_ID (ptr, xasl_id);
ptr = or_unpack_string_alloc (reply_data, stmt_info);
if (*stmt_info == NULL)
{
req_error = ER_GENERIC_ERROR;
goto error;
}
if (get_xasl_header)
{
OR_UNPACK_XASL_NODE_HEADER (ptr, xasl_header_p);
}
if (request != NULL)
{
free_and_init (request);
}
if (reply_data != NULL)
{
free_and_init (reply_data);
}
return req_error;
error:
if (request != NULL)
{
free_and_init (request);
}
if (reply_data != NULL)
{
free_and_init (reply_data);
}
return req_error;
#else
int result = NO_ERROR;
int stmt_info_len = 0;
THREAD_ENTRY *thread_p = enter_server ();
INIT_XASL_NODE_HEADER (xasl_header_p);
result = xsession_get_prepared_statement (thread_p, name, stmt_info, &stmt_info_len, xasl_id, xasl_header_p);
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_delete_prepared_statement () - delete a prepared session statement
* return : error code or no error
* name (in) : name of the prepared statement
*/
int
csession_delete_prepared_statement (const char *name)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *request = NULL;
int name_len, req_len;
req_len = length_const_string (name, &name_len);
request = (char *) malloc (req_len);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_len);
return ER_FAILED;
}
pack_const_string_with_length (request, name, name_len);
req_error =
net_client_request (NET_SERVER_SES_DELETE_PREPARED_STATEMENT, request, req_len,
OR_ALIGNED_BUF_START (a_reply), OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (request != NULL)
{
free_and_init (request);
}
if (req_error != NO_ERROR)
{
return ER_FAILED;
}
or_unpack_int (OR_ALIGNED_BUF_START (a_reply), &req_error);
return req_error;
#else
int result = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
result = xsession_delete_prepared_statement (thread_p, name);
exit_server (*thread_p);
return result;
#endif
}
/*
* clogin_user () - login user
* return : error code or NO_ERROR
* username (in) : name of the user
*/
int
clogin_user (const char *username)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *request = NULL;
int username_len, req_len;
req_len = length_const_string (username, &username_len);
request = (char *) malloc (req_len);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_len);
return ER_FAILED;
}
pack_const_string_with_length (request, username, username_len);
req_error =
net_client_request (NET_SERVER_AU_LOGIN_USER, request, req_len, OR_ALIGNED_BUF_START (a_reply),
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (request != NULL)
{
free_and_init (request);
}
if (req_error != NO_ERROR)
{
return ER_FAILED;
}
or_unpack_int (OR_ALIGNED_BUF_START (a_reply), &req_error);
return req_error;
#else
int result = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
result = xlogin_user (thread_p, username);
exit_server (*thread_p);
return result;
#endif
}
/*
* csession_set_session_variables () - set session variables
* return : error code or NO_ERROR
* variables (in) : variables
* count (in) : count
*/
int
csession_set_session_variables (DB_VALUE * variables, const int count)
{
#if defined (CS_MODE)
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request = NULL, *data_request = NULL, *ptr = NULL;
int req_size = 0, i = 0, err = NO_ERROR;
request = OR_ALIGNED_BUF_START (a_request);
or_pack_int (request, count);
req_size = 0;
for (i = 0; i < count; i++)
{
req_size += OR_VALUE_ALIGNED_SIZE (&variables[i]);
}
data_request = (char *) malloc (req_size);
if (data_request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_size);
err = ER_FAILED;
goto cleanup;
}
ptr = data_request;
for (i = 0; i < count; i++)
{
ptr = or_pack_db_value (ptr, &variables[i]);
}
err =
net_client_request (NET_SERVER_SES_SET_SESSION_VARIABLES, OR_ALIGNED_BUF_START (a_request),
OR_ALIGNED_BUF_SIZE (a_request), OR_ALIGNED_BUF_START (a_reply),
OR_ALIGNED_BUF_SIZE (a_reply), data_request, req_size, NULL, 0);
if (err != NO_ERROR)
{
goto cleanup;
}
or_unpack_int (OR_ALIGNED_BUF_START (a_reply), &err);
cleanup:
if (data_request != NULL)
{
free_and_init (data_request);
}
return err;
#else
int err = 0;
THREAD_ENTRY *thread_p = enter_server ();
err = xsession_set_session_variables (thread_p, variables, count);
exit_server (*thread_p);
return err;
#endif
}
/*
* csession_drop_session_variables () - drop session variables
* return : error code or NO_ERROR
* variables (in) : variables
* count (in) : count
*/
int
csession_drop_session_variables (DB_VALUE * variables, const int count)
{
#if defined (CS_MODE)
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request = NULL, *data_request = NULL, *ptr = NULL;
int req_size = 0, i = 0, err = NO_ERROR;
request = OR_ALIGNED_BUF_START (a_request);
or_pack_int (request, count);
req_size = 0;
for (i = 0; i < count; i++)
{
req_size += OR_VALUE_ALIGNED_SIZE (&variables[i]);
}
data_request = (char *) malloc (req_size);
if (data_request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_size);
err = ER_FAILED;
goto cleanup;
}
ptr = data_request;
for (i = 0; i < count; i++)
{
ptr = or_pack_db_value (ptr, &variables[i]);
}
err =
net_client_request (NET_SERVER_SES_DROP_SESSION_VARIABLES, OR_ALIGNED_BUF_START (a_request),
OR_ALIGNED_BUF_SIZE (a_request), OR_ALIGNED_BUF_START (a_reply),
OR_ALIGNED_BUF_SIZE (a_reply), data_request, req_size, NULL, 0);
if (err != NO_ERROR)
{
goto cleanup;
}
or_unpack_int (OR_ALIGNED_BUF_START (a_reply), &err);
cleanup:
if (data_request != NULL)
{
free_and_init (data_request);
}
return err;
#else
int err = 0;
THREAD_ENTRY *thread_p = enter_server ();
err = xsession_drop_session_variables (thread_p, variables, count);
exit_server (*thread_p);
return err;
#endif
}
/*
* csession_get_variable () - get the value of a session variable
* return : error code or NO_ERROR
* name (in) : the name of the session variable
* value (out) : the value of the session variable
*/
int
csession_get_variable (DB_VALUE * name, DB_VALUE * value)
{
#if defined (CS_MODE)
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *request = NULL, *reply = NULL, *ptr = NULL;
int req_size = 0, err = NO_ERROR, reply_size = 0;
assert (value != NULL);
req_size = OR_VALUE_ALIGNED_SIZE (name);
request = (char *) malloc (req_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_size);
return ER_FAILED;
}
or_pack_db_value (request, name);
err =
net_client_request2 (NET_SERVER_SES_GET_SESSION_VARIABLE, request, req_size,
OR_ALIGNED_BUF_START (a_reply), OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &reply, &reply_size);
if (err != NO_ERROR)
{
goto cleanup;
}
/* a_reply contains reply_size code and error code */
ptr = OR_ALIGNED_BUF_START (a_reply);
ptr = or_unpack_int (ptr, &err);
ptr = or_unpack_int (ptr, &err);
if (err != NO_ERROR)
{
goto cleanup;
}
or_unpack_db_value (reply, value);
cleanup:
if (request != NULL)
{
free_and_init (request);
}
if (reply != NULL)
{
free_and_init (reply);
}
return err;
#else
int err = NO_ERROR;
DB_VALUE *val_ref = NULL;
THREAD_ENTRY *thread_p = enter_server ();
/* we cannot use the allocation methods from the server context so we will just get a reference here */
err = xsession_get_session_variable_no_copy (thread_p, name, &val_ref);
exit_server (*thread_p);
if (err == NO_ERROR)
{
assert (val_ref != NULL);
/* create a clone of this value to be used in the client scope */
pr_clone_value (val_ref, value);
}
else
{
db_make_null (value);
}
return err;
#endif
}
/*
* boot_soft_rename -
*
* return:
*
* NOTE:
*/
int
boot_soft_rename (const char *old_db_name, const char *new_db_name, const char *new_db_path, const char *new_log_path,
const char *new_db_server_host, const char *new_volext_path, const char *fileof_vols_and_renamepaths,
bool new_db_overwrite, bool extern_rename, bool force_delete)
{
#if defined(CS_MODE)
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ONLY_IN_STANDALONE, 1, "install database");
return ER_FAILED;
#else /* CS_MODE */
int error_code;
THREAD_ENTRY *thread_p = enter_server ();
error_code =
xboot_soft_rename (thread_p, old_db_name, new_db_name, new_db_path, new_log_path, new_db_server_host,
new_volext_path, fileof_vols_and_renamepaths, new_db_overwrite, extern_rename, force_delete);
exit_server (*thread_p);
return error_code;
#endif /* !CS_MODE */
}
/*
* boot_copy () - copy the database to a new destination
*
* return : NO_ERROR if all OK, ER_ status otherwise
*
* fromdb_name(in): The database from where the copy is made.
* newdb_name(in): Name of new database
* newdb_path(in): Directory where the new database will reside
* newlog_path(in): Directory where the log volumes of the new database will reside
* new_lob_path(in): Directory where the lob volumes of the new database will reside
* newdb_server_host(in): Server host where the new database reside
* new_volext_path(in): A path is included if all volumes are placed in one place/directory. If NULL is given,
* - If file "fileof_vols_and_wherepaths" is given, the path is found in this file.
* - Each volume is copied to same place where the volume resides.
* Note: This parameter should be NULL, if the above file is given.
* fileof_vols_and_wherepaths(in): A file is given when the user decides to control the copy/rename of the volume by
* individual bases. That is, user decides to spread the volumes over several locations and
* or to label the volumes with specific names.
* Each volume entry consists of: volid from_fullvolname to_fullvolname
* newdb_overwrite(in): Whether to overwrite the new database if it already exist.
*/
int
boot_copy (const char *from_dbname, const char *new_db_name, const char *new_db_path, const char *new_log_path,
const char *new_lob_path, const char *new_db_server_host,
const char *new_volext_path, const char *fileof_vols_and_copypaths, bool new_db_overwrite)
{
#if defined(CS_MODE)
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ONLY_IN_STANDALONE, 1, "copy database");
return ER_FAILED;
#else /* CS_MODE */
int error_code;
THREAD_ENTRY *thread_p = enter_server ();
error_code =
xboot_copy (thread_p, from_dbname, new_db_name, new_db_path, new_log_path, new_lob_path, new_db_server_host,
new_volext_path, fileof_vols_and_copypaths, new_db_overwrite);
assert (thread_p == NULL);
exit_server_no_thread_entry ();
return error_code;
#endif /* !CS_MODE */
}
/*
* boot_emergency_patch -
*
* return:
*
* NOTE:
*/
int
boot_emergency_patch (const char *db_name, bool recreate_log, DKNPAGES log_npages, const char *db_locale, FILE * out_fp)
{
#if defined(CS_MODE)
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ONLY_IN_STANDALONE, 1, "emergency patch");
return ER_FAILED;
#else /* CS_MODE */
int error_code;
enter_server_no_thread_entry ();
error_code = xboot_emergency_patch (db_name, recreate_log, log_npages, db_locale, out_fp);
exit_server_no_thread_entry ();
return error_code;
#endif /* !CS_MODE */
}
/*
* boot_change_ha_mode - change server's HA state
* return: new state
*/
HA_SERVER_STATE
boot_change_ha_mode (HA_SERVER_STATE state, bool force, int timeout)
{
#if defined(CS_MODE)
int req_error;
int server_state;
HA_SERVER_STATE cur_state = HA_SERVER_STATE_NA;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE + OR_INT_SIZE) a_request;
char *request;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request = OR_ALIGNED_BUF_START (a_request);
ptr = or_pack_int (request, (int) state);
ptr = or_pack_int (ptr, (int) force);
ptr = or_pack_int (ptr, (int) timeout);
req_error =
net_client_request (NET_SERVER_BO_CHANGE_HA_MODE, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &server_state);
cur_state = (HA_SERVER_STATE) server_state;
}
return cur_state;
#else /* CS_MODE */
/* Cannot run in standalone mode */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_NOT_IN_STANDALONE, 1, "changemode");
return HA_SERVER_STATE_NA;
#endif /* !CS_MODE */
}
/*
* boot_notify_ha_log_applier_state - notify log applier's state to the server
* return: NO_ERROR or ER_FAILED
*/
int
boot_notify_ha_log_applier_state (HA_LOG_APPLIER_STATE state)
{
#if defined(CS_MODE)
int req_error, status = ER_FAILED;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request = OR_ALIGNED_BUF_START (a_request);
ptr = or_pack_int (request, (int) state);
req_error =
net_client_request (NET_SERVER_BO_NOTIFY_HA_LOG_APPLIER_STATE, request,
OR_ALIGNED_BUF_SIZE (a_request), reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
return status;
#else /* CS_MODE */
/* Cannot run in standalone mode */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_NOT_IN_STANDALONE, 1, "log applier");
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* stats_get_statistics_from_server () -
*
* return: error code
*
* classoid(in):
* timestamp(in):
* length_ptr(in):
* stats_buffer(in/out):
*
* NOTE:
*/
int
stats_get_statistics_from_server (OID * classoid, unsigned int timestamp, int *length_ptr, char **stats_buffer)
{
#if defined(CS_MODE)
int req_error;
char *area = NULL;
char *ptr;
OR_ALIGNED_BUF (OR_OID_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
assert (stats_buffer != NULL);
*stats_buffer = NULL;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, classoid);
ptr = or_pack_int (ptr, (int) timestamp);
req_error =
net_client_request2 (NET_SERVER_QST_GET_STATISTICS, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, length_ptr);
if (!req_error)
{
or_unpack_int (reply, length_ptr);
*stats_buffer = area;
}
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
*stats_buffer = xstats_get_statistics_from_server (thread_p, classoid, timestamp, length_ptr);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* stats_update_statistics -
*
* return:
*
* classoid(in):
* with_fullscan(in):
*
* NOTE:
*/
int
stats_update_statistics (MOP classop, int with_fullscan)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *request = NULL;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
char *ptr;
int request_size;
CLASS_ATTR_NDV class_attr_ndv = CLASS_ATTR_NDV_INITIALIZER;
/* get NDV by query */
if (stats_get_ndv_by_query (classop, &class_attr_ndv, NULL, with_fullscan) != NO_ERROR)
{
error = ER_FAILED;
goto end;
}
request_size = OR_INT_SIZE + (sizeof (ATTR_NDV) * (class_attr_ndv.attr_cnt + 1)) + OR_INT_SIZE + OR_OID_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
error = ER_OUT_OF_VIRTUAL_MEMORY;
goto end;
}
ptr = or_pack_int (request, class_attr_ndv.attr_cnt);
for (int i = 0; i < class_attr_ndv.attr_cnt + 1; i++)
{
ptr = or_pack_int (ptr, class_attr_ndv.attr_ndv[i].id);
ptr = or_pack_int64 (ptr, class_attr_ndv.attr_ndv[i].ndv);
}
ptr = or_pack_oid (ptr, WS_OID (classop));
ptr = or_pack_int (ptr, with_fullscan);
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_QST_UPDATE_STATISTICS, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_errcode (reply, &error);
}
end:
if (class_attr_ndv.attr_ndv != NULL)
{
free_and_init (class_attr_ndv.attr_ndv);
}
if (request)
{
free_and_init (request);
}
return error;
#else /* CS_MODE */
int error = NO_ERROR;
CLASS_ATTR_NDV class_attr_ndv = CLASS_ATTR_NDV_INITIALIZER;
THREAD_ENTRY *thread_p;
/* get NDV by query */
if (stats_get_ndv_by_query (classop, &class_attr_ndv, NULL, with_fullscan) != NO_ERROR)
{
error = ER_FAILED;
goto end;
}
thread_p = enter_server ();
error = xstats_update_statistics (thread_p, WS_OID (classop), with_fullscan, &class_attr_ndv);
exit_server (*thread_p);
end:
if (class_attr_ndv.attr_ndv != NULL)
{
free_and_init (class_attr_ndv.attr_ndv);
}
return error;
#endif /* !CS_MODE */
}
static int
is_top_level_class (MOBJ mobj)
{
assert (mobj != NULL);
SM_CLASS *class_ = (SM_CLASS *) mobj;
bool is_class = class_->class_type == SM_CLASS_CT;
bool is_root_partition_class = (class_->partition == NULL ||
class_->partition->class_partition_type == DB_PARTITIONED_CLASS);
return (is_class && is_root_partition_class);
}
/*
* stats_update_all_statistics -
*
* return:
* with_fullscan(in): true iff WITH FULLSCAN
*
* NOTE:
*/
int
stats_update_all_statistics (int with_fullscan)
{
int error = NO_ERROR;
MOP class_mop = NULL;
LIST_MOPS *lmops = NULL;
lmops = locator_get_all_class_mops (DB_FETCH_READ, is_top_level_class);
if (lmops == NULL)
{
return ER_FAILED;
}
for (int i = 0; i < lmops->num; i++)
{
class_mop = lmops->mops[i];
if (locator_fetch_class (class_mop, DB_FETCH_READ) != NULL)
{
error = stats_update_statistics (class_mop, with_fullscan);
if (error != NO_ERROR)
{
break;
}
}
}
locator_free_list_mops (lmops);
return error;
}
/*
* btree_add_index () -
*
* return:
*
* btid(in):
* key_type(in):
* class_oid(in):
* attr_id(in):
* unique_pk(in):
*
* NOTE:
*/
int
btree_add_index (BTID * btid, TP_DOMAIN * key_type, OID * class_oid, int attr_id, int unique_pk,
int deduplicate_key_pos)
{
#if defined(CS_MODE)
int error = NO_ERROR;
int req_error, request_size, domain_size;
char *ptr;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_BTID_ALIGNED_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
domain_size = or_packed_domain_size (key_type, 0);
request_size = OR_BTID_ALIGNED_SIZE + domain_size + OR_OID_SIZE + OR_INT_SIZE + OR_INT_SIZE;
request_size += OR_INT_SIZE; /* support for SUPPORT_DEDUPLICATE_KEY_MODE */
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = or_pack_btid (request, btid);
ptr = or_pack_domain (ptr, key_type, 0, 0);
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, attr_id);
ptr = or_pack_int (ptr, unique_pk);
ptr = or_pack_int (ptr, deduplicate_key_pos); /* support for SUPPORT_DEDUPLICATE_KEY_MODE */
req_error =
net_client_request (NET_SERVER_BTREE_ADDINDEX, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &error);
ptr = or_unpack_btid (ptr, btid);
if (error != NO_ERROR)
{
btid = NULL;
}
}
else
{
error = req_error;
}
free_and_init (request);
return error;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
btid = xbtree_add_index (thread_p, btid, key_type, class_oid, attr_id, unique_pk, 0, 0, 0, deduplicate_key_pos);
if (btid == NULL)
{
assert (er_errid () != NO_ERROR);
error = er_errid ();
}
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* btree_load_index -
*
* return:
*
* btid(in):
* bt_name(in):
* key_type(in):
* class_oids(in):
* n_classes(in):
* n_attrs(in):
* attr_ids(in):
* hfids(in):
* unique_pk(in):
* fk_refcls_oid(in):
* fk_refcls_pk_btid(in):
* fk_name(in):
*
* NOTE:
*/
int
btree_load_index (BTID * btid, const char *bt_name, TP_DOMAIN * key_type, OID * class_oids, int n_classes, int n_attrs,
int *attr_ids, int *attrs_prefix_length, HFID * hfids, int unique_pk, int not_null_flag,
OID * fk_refcls_oid, BTID * fk_refcls_pk_btid, const char *fk_name, char *pred_stream,
int pred_stream_size, char *expr_stream, int expr_stream_size, int func_col_id,
int func_attr_index_start, SM_INDEX_STATUS index_status)
{
#if defined(CS_MODE)
int error = NO_ERROR, req_error, request_size, domain_size;
char *ptr;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE * 2 + OR_BTID_ALIGNED_SIZE) a_reply;
char *reply;
int i, total_attrs, bt_strlen, fk_strlen;
int index_info_size = 0;
char *stream = NULL;
int stream_size = 0;
LOCK curr_cls_lock = SCH_M_LOCK;
// online index should have created the empty b-tree already
assert (index_status != SM_ONLINE_INDEX_BUILDING_IN_PROGRESS || !BTID_IS_NULL (btid));
reply = OR_ALIGNED_BUF_START (a_reply);
if (pred_stream && expr_stream)
{
return ER_FAILED;
}
index_info_size = (OR_INT_SIZE /* index info type */
+ (pred_stream ? OR_INT_SIZE : 0) + (expr_stream ? OR_INT_SIZE * 3 : 0));
domain_size = or_packed_domain_size (key_type, 0);
request_size = (OR_BTID_ALIGNED_SIZE /* BTID */
+ or_packed_string_length (bt_name, &bt_strlen) /* index name */
+ domain_size /* key_type */
+ (n_classes * OR_OID_SIZE) /* class_oids */
+ OR_INT_SIZE /* n_classes */
+ OR_INT_SIZE /* n_attrs */
+ (n_classes * n_attrs * OR_INT_SIZE) /* attr_ids */
+ ((n_classes == 1) ? (n_attrs * OR_INT_SIZE) : 0) /* attrs_prefix_length */
+ (n_classes * OR_HFID_SIZE) /* hfids */
+ OR_INT_SIZE /* unique_pk */
+ OR_INT_SIZE /* not_null_flag */
+ OR_OID_SIZE /* fk_refcls_oid */
+ OR_BTID_ALIGNED_SIZE /* fk_refcls_pk_btid */
+ or_packed_string_length (fk_name, &fk_strlen) /* fk_name */
+ index_info_size /* filter predicate or function index stream size */
+ OR_INT_SIZE /* Index status */
+ OR_INT_SIZE /* Thread count */ );
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = or_pack_btid (request, btid);
ptr = or_pack_string_with_length (ptr, bt_name, bt_strlen);
ptr = or_pack_domain (ptr, key_type, 0, 0);
ptr = or_pack_int (ptr, n_classes);
ptr = or_pack_int (ptr, n_attrs);
for (i = 0; i < n_classes; i++)
{
ptr = or_pack_oid (ptr, &class_oids[i]);
}
total_attrs = n_classes * n_attrs;
for (i = 0; i < total_attrs; i++)
{
ptr = or_pack_int (ptr, attr_ids[i]);
}
if (n_classes == 1)
{
for (i = 0; i < n_attrs; i++)
{
if (attrs_prefix_length)
{
ptr = or_pack_int (ptr, attrs_prefix_length[i]);
}
else
{
ptr = or_pack_int (ptr, -1);
}
}
}
for (i = 0; i < n_classes; i++)
{
ptr = or_pack_hfid (ptr, &hfids[i]);
}
ptr = or_pack_int (ptr, unique_pk);
ptr = or_pack_int (ptr, not_null_flag);
ptr = or_pack_oid (ptr, fk_refcls_oid);
ptr = or_pack_btid (ptr, fk_refcls_pk_btid);
ptr = or_pack_string_with_length (ptr, fk_name, fk_strlen);
if (pred_stream)
{
ptr = or_pack_int (ptr, 0);
ptr = or_pack_int (ptr, pred_stream_size);
stream = pred_stream;
stream_size = pred_stream_size;
}
else if (expr_stream)
{
ptr = or_pack_int (ptr, 1);
ptr = or_pack_int (ptr, expr_stream_size);
ptr = or_pack_int (ptr, func_col_id);
ptr = or_pack_int (ptr, func_attr_index_start);
stream = expr_stream;
stream_size = expr_stream_size;
}
else
{
ptr = or_pack_int (ptr, -1); /* stream=NULL, stream_size=0 */
}
ptr = or_pack_int (ptr, index_status); /* Index status. */
ptr = or_pack_int (ptr, ib_get_thread_count ()); // Thread count needed for parallel building
req_error =
net_client_request (NET_SERVER_BTREE_LOADINDEX, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), stream, stream_size, NULL, 0);
if (req_error == NO_ERROR)
{
int t;
ptr = or_unpack_int (reply, &error);
ptr = or_unpack_int (ptr, &t);
curr_cls_lock = (LOCK) t;
if (index_status == SM_ONLINE_INDEX_BUILDING_IN_PROGRESS)
{
BTID local_btid;
ptr = or_unpack_btid (ptr, &local_btid);
if (error != NO_ERROR)
{
btid = NULL;
}
assert (!BTID_IS_NULL (&local_btid));
}
else
{
ptr = or_unpack_btid (ptr, btid);
if (error != NO_ERROR)
{
btid = NULL;
}
}
}
else
{
btid = NULL;
error = req_error;
}
if (index_status == SM_ONLINE_INDEX_BUILDING_IN_PROGRESS && curr_cls_lock != SCH_M_LOCK)
{
// hope it won't happen. server failed to restore the demoted lock.
// It just help things don't go worse.
MOP class_mop = ws_mop (&class_oids[0], sm_Root_class_mop);
if (class_mop != NULL)
{
ws_set_lock (class_mop, curr_cls_lock);
}
}
free_and_init (request);
return error;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
if (index_status == SM_ONLINE_INDEX_BUILDING_IN_PROGRESS)
{
btid =
xbtree_load_online_index (thread_p, btid, bt_name, key_type, class_oids, n_classes, n_attrs, attr_ids,
attrs_prefix_length, hfids, unique_pk, not_null_flag, fk_refcls_oid,
fk_refcls_pk_btid, fk_name, pred_stream, pred_stream_size, expr_stream,
expr_stream_size, func_col_id, func_attr_index_start, 1);
}
else
{
btid =
xbtree_load_index (thread_p, btid, bt_name, key_type, class_oids, n_classes, n_attrs, attr_ids,
attrs_prefix_length, hfids, unique_pk, not_null_flag, fk_refcls_oid, fk_refcls_pk_btid,
fk_name, pred_stream, pred_stream_size, expr_stream, expr_stream_size, func_col_id,
func_attr_index_start);
}
if (btid == NULL)
{
assert (er_errid () != NO_ERROR);
error = er_errid ();
}
else
{
error = NO_ERROR;
}
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* btree_delete_index -
*
* return:
*
* btid(in):
*
* NOTE:
*/
int
btree_delete_index (BTID * btid)
{
#if defined(CS_MODE)
int req_error, status = NO_ERROR;
OR_ALIGNED_BUF (OR_BTID_ALIGNED_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_btid (request, btid);
req_error =
net_client_request (NET_SERVER_BTREE_DELINDEX, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
else
{
status = req_error;
}
return status;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xbtree_delete_index (thread_p, btid);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_log_force_nologging -
*
* return:
*
* NOTE:
*/
int
locator_log_force_nologging (void)
{
#if defined(CS_MODE)
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_ONLY_IN_STANDALONE, 1, "no logging");
return ER_FAILED;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = log_set_no_logging ();
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* locator_remove_class_from_index -
*
* return:
*
* oid(in):
* btid(in):
* hfid(in):
*
* NOTE:
*/
int
locator_remove_class_from_index (OID * oid, BTID * btid, HFID * hfid)
{
#if defined(CS_MODE)
char *request, *reply, *ptr;
int req_error, status = NO_ERROR;
OR_ALIGNED_BUF (OR_OID_SIZE + OR_BTID_ALIGNED_SIZE + OR_HFID_SIZE) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, oid);
ptr = or_pack_btid (ptr, btid);
ptr = or_pack_hfid (ptr, hfid);
req_error =
net_client_request (NET_SERVER_LC_REM_CLASS_FROM_INDEX, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
else
{
status = req_error;
}
return status;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_remove_class_from_index (thread_p, oid, btid, hfid);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* btree_find_unique -
*
* return:
*
* btid(in):
* key(in):
* class_oid(in):
* oid(in):
*
* NOTE:
*/
BTREE_SEARCH
btree_find_unique (BTID * btid, DB_VALUE * key, OID * class_oid, OID * oid)
{
#if defined(CS_MODE)
BTREE_SEARCH status = BTREE_ERROR_OCCURRED;
int req_error, request_size, key_size;
char *ptr;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_OID_SIZE) a_reply;
char *reply;
enum net_server_request request_id;
if (btid == NULL || key == NULL || class_oid == NULL || oid == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OBJ_INVALID_ARGUMENTS, 0);
return BTREE_ERROR_OCCURRED;
}
reply = OR_ALIGNED_BUF_START (a_reply);
key_size = OR_VALUE_ALIGNED_SIZE (key);
request_size = key_size + OR_OID_SIZE + OR_BTID_ALIGNED_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return BTREE_ERROR_OCCURRED;
}
ptr = request;
ptr = or_pack_value (ptr, key);
request_id = NET_SERVER_BTREE_FIND_UNIQUE;
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_btid (ptr, btid);
/* reset request_size as real packed size */
request_size = CAST_BUFLEN (ptr - request);
req_error =
net_client_request (request_id, request, request_size, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
int istatus;
ptr = or_unpack_int (reply, &istatus);
ptr = or_unpack_oid (ptr, oid);
status = (BTREE_SEARCH) istatus;
}
else
{
OID_SET_NULL (oid);
}
free_and_init (request);
return status;
#else /* CS_MODE */
BTREE_SEARCH status = BTREE_ERROR_OCCURRED;
if (btid == NULL || key == NULL || class_oid == NULL || oid == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OBJ_INVALID_ARGUMENTS, 0);
return BTREE_ERROR_OCCURRED;
}
THREAD_ENTRY *thread_p = enter_server ();
status = xbtree_find_unique (thread_p, btid, S_SELECT_WITH_LOCK, key, class_oid, oid, false);
exit_server (*thread_p);
return status;
#endif /* !CS_MODE */
}
/*
* btree_find_multi_uniques () - search a list of indexes of a specified class for a list of values
* return: index search result or BTREE_ERROR_OCCURRED
* class_oid (in) : class OID
* pruning_type (in) : pruning type
* btids (in) : list of indexes to search
* keys (in) : list of values to search for
* count (in) : number of indexes
* op_type (in) : operation type
* oids (in/out) : found OIDs
* oids_count (in/out) : number of OIDs found
*/
BTREE_SEARCH
btree_find_multi_uniques (OID * class_oid, int pruning_type, BTID * btids, DB_VALUE * keys, int count,
SCAN_OPERATION_TYPE op_type, OID ** oids, int *oids_count)
{
#if defined (CS_MODE)
int req_error, req_size, area_size, i;
/* reply contains area size and return code */
OR_ALIGNED_BUF (2 * OR_INT_SIZE) a_reply;
char *request = NULL, *ptr = NULL;
char *area = NULL;
BTREE_SEARCH result = BTREE_KEY_NOTFOUND;
/* compute request size */
req_size = (OR_INT_SIZE /* number of indexes to search */
+ OR_INT_SIZE /* needs pruning */
+ OR_OID_SIZE /* class OID */
+ OR_INT_SIZE /* operation type */
+ (count * OR_BTID_ALIGNED_SIZE) /* indexes */ );
for (i = 0; i < count; i++)
{
req_size += OR_VALUE_ALIGNED_SIZE (&keys[i]);
}
request = (char *) malloc (req_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_size);
result = BTREE_ERROR_OCCURRED;
goto cleanup;
}
/* pack oid */
ptr = or_pack_oid (request, class_oid);
/* needs pruning */
ptr = or_pack_int (ptr, pruning_type);
/* operation type */
ptr = or_pack_int (ptr, op_type);
/* number of indexes */
ptr = or_pack_int (ptr, count);
/* indexes */
for (i = 0; i < count; i++)
{
ptr = or_pack_btid (ptr, &btids[i]);
}
/* values */
for (i = 0; i < count; i++)
{
ptr = or_pack_value (ptr, &keys[i]);
}
req_error =
net_client_request2 (NET_SERVER_BTREE_FIND_MULTI_UNIQUES, request, req_size,
OR_ALIGNED_BUF_START (a_reply), OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (req_error != NO_ERROR)
{
result = BTREE_ERROR_OCCURRED;
goto cleanup;
}
/* skip over area_size */
ptr = or_unpack_int (OR_ALIGNED_BUF_START (a_reply), &area_size);
/* unpack error code returned from server */
ptr = or_unpack_int (ptr, &req_error);
if (req_error != NO_ERROR)
{
result = BTREE_ERROR_OCCURRED;
goto cleanup;
}
/* if no data was returned, no offending OID was found */
if (area_size == 0)
{
*oids = NULL;
result = BTREE_KEY_NOTFOUND;
goto cleanup;
}
/* unpack number of returned OIDs */
ptr = or_unpack_int (area, oids_count);
if (*oids_count == 0)
{
assert (false);
*oids = NULL;
result = BTREE_KEY_NOTFOUND;
goto cleanup;
}
else
{
assert (*oids_count > 0);
result = BTREE_KEY_FOUND;
}
*oids = (OID *) malloc ((*oids_count) * sizeof (OID));
if (*oids == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) req_size);
result = BTREE_ERROR_OCCURRED;
goto cleanup;
}
for (i = 0; i < *oids_count; i++)
{
ptr = or_unpack_oid (ptr, &((*oids)[i]));
}
cleanup:
if (request != NULL)
{
free_and_init (request);
}
if (area != NULL)
{
free_and_init (area);
}
if (result != BTREE_KEY_FOUND)
{
*oids_count = 0;
*oids = NULL;
}
return result;
#else
BTREE_SEARCH result = BTREE_KEY_NOTFOUND;
OID *local_oids = NULL;
int local_count = 0;
THREAD_ENTRY *thread_p = enter_server ();
result =
xbtree_find_multi_uniques (thread_p, class_oid, pruning_type, btids, keys, count, op_type, &local_oids,
&local_count);
if (result == BTREE_ERROR_OCCURRED)
{
exit_server (*thread_p);
return result;
}
/* need to copy memory from server context to local context */
if (local_count > 0)
{
*oids = (OID *) malloc (local_count * sizeof (OID));
if (*oids == NULL)
{
db_private_free (thread_p, local_oids);
exit_server (*thread_p);
return BTREE_ERROR_OCCURRED;
}
*oids_count = local_count;
memcpy (*oids, local_oids, local_count * sizeof (OID));
db_private_free (thread_p, local_oids);
}
exit_server (*thread_p);
return result;
#endif
}
/*
* btree_class_test_unique -
*
* return:
*
* buf(in):
* buf_size(in):
*
* NOTE:
*/
int
btree_class_test_unique (char *buf, int buf_size)
{
#if defined(CS_MODE)
int req_error, status = NO_ERROR;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_BTREE_CLASS_UNIQUE_TEST, buf, buf_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
else
{
status = req_error;
}
return status;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xbtree_class_test_unique (thread_p, buf, buf_size);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* qfile_get_list_file_page -
*
* return:
*
* query_id(in):
* volid(in):
* pageid(in):
* buffer(in):
* buffer_size(in):
*
* NOTE:
*/
int
qfile_get_list_file_page (QUERY_ID query_id, VOLID volid, PAGEID pageid, char *buffer, int *buffer_size)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_PTR_SIZE + OR_INT_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_ptr (request, query_id);
ptr = or_pack_int (ptr, (int) volid);
ptr = or_pack_int (ptr, (int) pageid);
req_error =
net_client_request2_no_malloc (NET_SERVER_LS_GET_LIST_FILE_PAGE, request,
OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, buffer, buffer_size);
if (!req_error)
{
ptr = or_unpack_int (&reply[OR_INT_SIZE], &error);
}
return error;
#else /* CS_MODE */
int success;
int page_size;
THREAD_ENTRY *thread_p = enter_server ();
success = xqfile_get_list_file_page (thread_p, query_id, volid, pageid, buffer, &page_size);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* qmgr_prepare_query - Send a SERVER_QM_PREPARE request to the server
*
* Send XASL stream and receive XASL file id (XASL_ID) as a result.
* If xasl_buffer == NULL, the server will look up the XASL cache and then
* return the cached XASL file id if found, otherwise return NULL.
* This function is a counter part to sqmgr_prepare_query().
*
* return: Error Code.
*
* context(in): query string & plan
* stream(in/out): xasl stream, size, xasl ID & xasl_header
*
* NOTE: If xasl_header_p is not null, also XASL node header will be requested
*/
int
qmgr_prepare_query (COMPILE_CONTEXT * context, xasl_stream * stream)
{
#if defined(CS_MODE)
int error = NO_ERROR;
int req_error, request_size = 0;
int sql_hash_text_len, sql_plan_text_len, reply_buffer_size = 0;
char *request = NULL, *reply = NULL, *ptr = NULL, *reply_buffer = NULL;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE + OR_XASL_ID_SIZE) a_reply;
int get_xasl_header = stream->xasl_header != NULL;
INIT_XASL_NODE_HEADER (stream->xasl_header);
reply = OR_ALIGNED_BUF_START (a_reply);
/* sql hash text */
request_size += length_const_string (context->sql_hash_text, &sql_hash_text_len);
/* sql plan text */
request_size += length_const_string (context->sql_plan_text, &sql_plan_text_len);
/* sql user text */
request_size += length_string_with_null_padding (context->sql_user_text_len);
request_size += OR_INT_SIZE; /* size */
request_size += OR_INT_SIZE; /* get_xasl_header */
request_size += OR_INT_SIZE; /* whether to pin xasl cache entry */
request_size += OR_INT_SIZE; /* whether to recompile the pinned xasl cache entry */
request_size += OR_INT_SIZE; /* context->recompile_xasl */
request_size += OR_SHA1_SIZE; /* sha1 */
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
/* pack query alias string as a request data */
ptr = pack_const_string_with_length (request, context->sql_hash_text, sql_hash_text_len);
/* pack query plan as a request data */
ptr = pack_const_string_with_length (ptr, context->sql_plan_text, sql_plan_text_len);
/* pack query string as a request data */
ptr = pack_string_with_null_padding (ptr, context->sql_user_text, context->sql_user_text_len);
/* pack size of XASL stream */
ptr = or_pack_int (ptr, stream->buffer_size);
/* Pack get_xasl_header. */
ptr = or_pack_int (ptr, get_xasl_header);
/* Pack context. */
ptr = or_pack_int (ptr, (int) context->is_xasl_pinned_reference);
ptr = or_pack_int (ptr, (int) context->recompile_xasl_pinned);
ptr = or_pack_int (ptr, (int) context->recompile_xasl);
ptr = or_pack_sha1 (ptr, &context->sha1);
/* send SERVER_QM_QUERY_PREPARE request with request data and XASL stream; receive XASL file id (XASL_ID) as a reply */
req_error =
net_client_request2 (NET_SERVER_QM_QUERY_PREPARE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), (char *) stream->buffer, stream->buffer_size,
&reply_buffer, &reply_buffer_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &reply_buffer_size);
ptr = or_unpack_int (ptr, &error);
if (error == NO_ERROR)
{
/* NULL XASL_ID will be returned when cache not found */
OR_UNPACK_XASL_ID (ptr, stream->xasl_id);
context->recompile_xasl = false;
if (reply_buffer != NULL && reply_buffer_size != 0)
{
ptr = reply_buffer;
if (get_xasl_header)
{
OR_UNPACK_XASL_NODE_HEADER (ptr, stream->xasl_header);
}
if (ptr < reply_buffer + reply_buffer_size)
{
/* Doesn't really matter what it's packed... We need to force recompile; see sqmgr_prepare_query */
assert ((ptr + OR_INT_SIZE) == (reply_buffer + reply_buffer_size));
assert (!context->recompile_xasl);
context->recompile_xasl = true;
}
}
}
else
{
ASSERT_ERROR ();
}
}
else
{
error = req_error;
}
if (request != NULL)
{
free_and_init (request);
}
if (reply_buffer != NULL)
{
free_and_init (reply_buffer);
}
return error;
#else /* CS_MODE */
int error_code = NO_ERROR;
XASL_STREAM server_stream;
THREAD_ENTRY *thread_p = enter_server ();
/* We cannot use the stream created on client context. XASL cache will save the stream in cache entry and it will
* suppose the stream buffer was allocated using malloc.
* Duplicate the stream for server context.
*/
server_stream.xasl_id = stream->xasl_id;
server_stream.xasl_header = stream->xasl_header;
server_stream.buffer_size = stream->buffer_size;
if (stream->buffer_size > 0)
{
server_stream.buffer = (char *) malloc (stream->buffer_size);
if (server_stream.buffer == NULL)
{
exit_server (*thread_p);
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, stream->buffer_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
memcpy (server_stream.buffer, stream->buffer, stream->buffer_size);
}
else
{
/* No stream. This is just a lookup for existing entry. */
server_stream.buffer = NULL;
}
INIT_XASL_NODE_HEADER (server_stream.xasl_header);
/* call the server routine of query prepare */
error_code = xqmgr_prepare_query (thread_p, context, &server_stream);
if (server_stream.buffer != NULL)
{
free_and_init (server_stream.buffer);
}
if (error_code != NO_ERROR)
{
ASSERT_ERROR ();
}
exit_server (*thread_p);
return error_code;
#endif /* !CS_MODE */
}
/*
* qmgr_execute_query - Send a SERVER_QM_EXECUTE request to the server
*
* Send XASL file id and parameter values if exist and receive list file id
* that contains query result. If an error occurs, return NULL QFILE_LIST_ID.
* This function is a counter part to sqmgr_execute_query().
*/
/*
* qmgr_execute_query -
*
* return:
*
* xasl_id(in):
* query_idp(in):
* dbval_cnt(in):
* dbvals(in):
* flag(in):
* clt_cache_time(in):
* srv_cache_time(in):
* query_timeout(in):
* end_of_queries(in):
*
* NOTE:
*/
QFILE_LIST_ID *
qmgr_execute_query (const XASL_ID * xasl_id, QUERY_ID * query_idp, int dbval_cnt, const DB_VALUE * dbvals,
QUERY_FLAG flag, CACHE_TIME * clt_cache_time, CACHE_TIME * srv_cache_time, int query_timeout)
{
#if defined(CS_MODE)
QFILE_LIST_ID *list_id = NULL;
int req_error, senddata_size, replydata_size_listid, replydata_size_page, replydata_size_plan;
char *request, *reply, *senddata = NULL;
char *replydata_listid = NULL, *replydata_page = NULL, *replydata_plan = NULL, *ptr;
OR_ALIGNED_BUF (OR_XASL_ID_SIZE + OR_INT_SIZE * 5 + OR_CACHE_TIME_SIZE
+ OR_PTR_SIZE * NET_DEFER_END_QUERIES_MAX + EXECUTE_QUERY_MAX_ARGUMENT_DATA_SIZE) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE * 7 + OR_PTR_ALIGNED_SIZE + OR_CACHE_TIME_SIZE) a_reply;
int i, request_len;
const DB_VALUE *dbval;
CACHE_TIME local_srv_cache_time;
int should_conn_reset, end_query_result, tran_state;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
/* make send data using if parameter values for host variables are given */
senddata_size = 0;
for (i = 0, dbval = dbvals; i < dbval_cnt; i++, dbval++)
{
senddata_size += OR_VALUE_ALIGNED_SIZE ((DB_VALUE *) dbval);
}
if (senddata_size != 0)
{
senddata = (char *) malloc (senddata_size);
if (senddata == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) senddata_size);
return NULL;
}
ptr = senddata;
for (i = 0, dbval = dbvals; i < dbval_cnt; i++, dbval++)
{
ptr = or_pack_db_value (ptr, (DB_VALUE *) dbval);
}
/* change senddata_size as real packing size */
senddata_size = CAST_BUFLEN (ptr - senddata);
if (senddata_size < EXECUTE_QUERY_MAX_ARGUMENT_DATA_SIZE)
{
flag |= EXECUTE_QUERY_WITHOUT_DATA_BUFFERS;
}
}
/* pack XASL file id (XASL_ID), number of parameter values, size of the send data, and query execution mode flag as a
* request data */
ptr = request;
OR_PACK_XASL_ID (ptr, xasl_id);
ptr = or_pack_int (ptr, dbval_cnt);
ptr = or_pack_int (ptr, senddata_size);
ptr = or_pack_int (ptr, flag);
OR_PACK_CACHE_TIME (ptr, clt_cache_time);
ptr = or_pack_int (ptr, query_timeout);
request_len = OR_XASL_ID_SIZE + OR_INT_SIZE * 4 + OR_CACHE_TIME_SIZE;
if (IS_QUERY_EXECUTE_WITH_COMMIT (flag))
{
assert (net_Deferred_end_queries_count <= NET_DEFER_END_QUERIES_MAX);
ptr = or_pack_int (ptr, net_Deferred_end_queries_count);
for (i = 0; i < net_Deferred_end_queries_count; i++)
{
ptr = or_pack_ptr (ptr, net_Deferred_end_queries[i]);
}
request_len += OR_INT_SIZE + OR_PTR_SIZE * net_Deferred_end_queries_count;
}
/* Add message in log in case of autocommit transactions. It helps to trace query execution. */
if (prm_get_bool_value (PRM_ID_ER_LOG_DEBUG) && IS_TRAN_AUTO_COMMIT (flag))
{
if (IS_QUERY_EXECUTE_WITH_COMMIT (flag))
{
er_log_debug (ARG_FILE_LINE, "qmgr_execute_query requested: EXECUTION_WITH_AUTOCOMMIT\n");
}
else
{
er_log_debug (ARG_FILE_LINE, "qmgr_execute_query requested: EXECUTION_WITHOUT_AUTOCOMMIT\n");
}
}
if (IS_QUERY_EXECUTED_WITHOUT_DATA_BUFFERS (flag))
{
/* Execute without data buffers. The data has small size. Include the data in the argument buffer. */
assert (senddata != NULL && 0 < senddata_size);
memcpy (ptr, senddata, senddata_size);
request_len += senddata_size;
free_and_init (senddata);
senddata_size = 0;
}
else
{
/* Execute with data buffer. The data has big size. */
}
req_error =
net_client_request_with_callback (NET_SERVER_QM_QUERY_EXECUTE, request, request_len, reply,
OR_ALIGNED_BUF_SIZE (a_reply), senddata, senddata_size, NULL, 0,
&replydata_listid, &replydata_size_listid, &replydata_page,
&replydata_size_page, &replydata_plan, &replydata_size_plan);
if (replydata_plan != NULL)
{
db_set_execution_plan (replydata_plan, replydata_size_plan);
free_and_init (replydata_plan);
}
if (senddata != NULL)
{
free_and_init (senddata);
}
if (!req_error)
{
/* first argument should be QUERY_END ptr = or_unpack_int(reply, &status); */
/* second argument should be the same with replydata_size_listid ptr = or_unpack_int(ptr, &listid_length); */
/* third argument should be the same with replydata_size_page ptr = or_unpack_int(ptr, &page_size); */
/* third argument should be the same with replydata_size_plan ptr = or_unpack_int(ptr, &plan_size); */
/* fourth argument should be query_id */
ptr = or_unpack_ptr (reply + OR_INT_SIZE * 4, query_idp);
OR_UNPACK_CACHE_TIME (ptr, &local_srv_cache_time);
if (srv_cache_time)
{
memcpy (srv_cache_time, &local_srv_cache_time, sizeof (CACHE_TIME));
}
if (IS_QUERY_EXECUTE_WITH_COMMIT (flag))
{
ptr = or_unpack_int (ptr, &end_query_result);
/* If all net_Deferred_end_queries are closed on the server, the value of end_query_result is NO_ERROR. */
/* If end_query_result is not NO_ERROR, net_Deferred_end_queries_count will not reset to attempt a close on commit or abort. */
if (end_query_result == NO_ERROR)
{
net_Deferred_end_queries_count = 0;
}
ptr = or_unpack_int (ptr, &tran_state);
ptr = or_unpack_int (ptr, &should_conn_reset);
if (tran_state == TRAN_UNACTIVE_COMMITTED || tran_state == TRAN_UNACTIVE_COMMITTED_INFORMING_PARTICIPANTS
|| tran_state == TRAN_UNACTIVE_ABORTED || tran_state == TRAN_UNACTIVE_ABORTED_INFORMING_PARTICIPANTS)
{
net_cleanup_client_queues ();
}
tran_set_latest_query_status (end_query_result, tran_state, should_conn_reset);
/* check if dblink transaction is aborted */
if (tran_state == TRAN_UNACTIVE_ABORTED_INFORMING_PARTICIPANTS)
{
if (replydata_listid)
{
free_and_init (replydata_listid);
}
return NULL;
}
}
if (replydata_listid && replydata_size_listid)
{
/* unpack list file id of query result from the reply data */
ptr = or_unpack_unbound_listid (replydata_listid, (void **) (&list_id));
/* QFILE_LIST_ID shipped with last page */
if (replydata_size_page)
{
list_id->last_pgptr = replydata_page;
}
else
{
list_id->last_pgptr = NULL;
}
free_and_init (replydata_listid);
}
}
return list_id;
#else /* CS_MODE */
QFILE_LIST_ID *list_id = NULL;
DB_VALUE *server_db_values = NULL;
OID *oid;
int i;
THREAD_ENTRY *thread_p = enter_server ();
/* reallocate dbvals to use server allocation */
if (dbval_cnt > 0)
{
size_t s = dbval_cnt * sizeof (DB_VALUE);
server_db_values = (DB_VALUE *) db_private_alloc (thread_p, s);
if (server_db_values == NULL)
{
goto cleanup;
}
for (i = 0; i < dbval_cnt; i++)
{
db_make_null (&server_db_values[i]);
}
for (i = 0; i < dbval_cnt; i++)
{
switch (DB_VALUE_TYPE (&dbvals[i]))
{
case DB_TYPE_OBJECT:
/* server cannot handle objects, convert to OID instead */
oid = ws_identifier (db_get_object (&dbvals[i]));
if (oid != NULL)
{
db_make_oid (&server_db_values[i], oid);
}
break;
default:
/* Clone value */
if (db_value_clone ((DB_VALUE *) (&dbvals[i]), &server_db_values[i]) != NO_ERROR)
{
goto cleanup;
}
break;
}
}
}
else
{
/* No dbvals */
server_db_values = NULL;
}
/* call the server routine of query execute */
list_id =
xqmgr_execute_query (thread_p, xasl_id, query_idp, dbval_cnt, server_db_values, &flag, clt_cache_time,
srv_cache_time, query_timeout, NULL);
cleanup:
if (server_db_values != NULL)
{
for (i = 0; i < dbval_cnt; i++)
{
db_value_clear (&server_db_values[i]);
}
db_private_free (thread_p, server_db_values);
}
exit_server (*thread_p);
return list_id;
#endif /* !CS_MODE */
}
/*
* qmgr_prepare_and_execute_query -
*
* return:
*
* xasl_stream(in):
* xasl_stream_size(in):
* query_id(in):
* dbval_cnt(in):
* dbval_ptr(in):
* flag(in):
* query_timeout(in):
*
* NOTE:
*/
QFILE_LIST_ID *
qmgr_prepare_and_execute_query (char *xasl_stream, int xasl_stream_size, QUERY_ID * query_idp, int dbval_cnt,
DB_VALUE * dbval_ptr, QUERY_FLAG flag, int query_timeout)
{
#if defined(CS_MODE)
QFILE_LIST_ID *regu_result = NULL;
int req_error, senddata_size, replydata_size_listid, replydata_size_page;
int i, size;
char *ptr, *senddata, *replydata;
DB_VALUE *dbval;
OR_ALIGNED_BUF (OR_INT_SIZE * 4) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE * 4 + OR_PTR_ALIGNED_SIZE) a_reply;
char *reply;
char *page_ptr;
int page_size, dummy_plan_size;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
senddata = NULL;
senddata_size = 0;
for (i = 0, dbval = dbval_ptr; i < dbval_cnt; i++, dbval++)
{
senddata_size += OR_VALUE_ALIGNED_SIZE (dbval);
}
if (senddata_size != 0)
{
senddata = (char *) malloc (senddata_size);
if (senddata == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) senddata_size);
return NULL;
}
}
ptr = or_pack_int (request, dbval_cnt);
ptr = or_pack_int (ptr, senddata_size);
ptr = or_pack_int (ptr, flag);
ptr = or_pack_int (ptr, query_timeout);
ptr = senddata;
for (i = 0, dbval = dbval_ptr; i < dbval_cnt; i++, dbval++)
{
ptr = or_pack_db_value (ptr, dbval);
}
/* change senddata_size as real packing size */
senddata_size = CAST_BUFLEN (ptr - senddata);
req_error = net_client_request_with_callback (NET_SERVER_QM_QUERY_PREPARE_AND_EXECUTE, request,
OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), xasl_stream,
xasl_stream_size, senddata, senddata_size, &replydata,
&replydata_size_listid, &page_ptr, &replydata_size_page, NULL, NULL);
if (!req_error)
{
/* should be the same as replydata_size */
ptr = or_unpack_int (&reply[OR_INT_SIZE], &size);
ptr = or_unpack_int (ptr, &page_size);
ptr = or_unpack_int (ptr, &dummy_plan_size);
ptr = or_unpack_ptr (ptr, query_idp);
/* not interested in the return size in the reply buffer, should do some kind of range checking here */
if (replydata != NULL && size)
{
ptr = or_unpack_unbound_listid (replydata, (void **) (®u_result));
regu_result->last_pgptr = NULL;
if (page_size)
{
regu_result->last_pgptr = page_ptr;
}
free_and_init (replydata);
}
}
if (senddata != NULL)
{
free_and_init (senddata);
}
return regu_result;
#else /* CS_MODE */
QFILE_LIST_ID *regu_result;
THREAD_ENTRY *thread_p = enter_server ();
regu_result =
xqmgr_prepare_and_execute_query (thread_p, xasl_stream, xasl_stream_size, query_idp, dbval_cnt, dbval_ptr, &flag,
query_timeout);
exit_server (*thread_p);
return regu_result;
#endif /* !CS_MODE */
}
/*
* qmgr_end_query -
*
* return:
*
* query_id(in):
*
* NOTE:
*/
int
qmgr_end_query (QUERY_ID query_id)
{
#if defined(CS_MODE)
int status = ER_FAILED;
int req_error = NO_ERROR;
int i = 0;
OR_ALIGNED_BUF (OR_INT_SIZE /* number of query ids */
+ OR_PTR_SIZE * NET_DEFER_END_QUERIES_MAX /* query ids */
+ MAX_ALIGNMENT /* alignment */
)a_request;
char *request = NULL, *ptr = NULL;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply = NULL;
net_Deferred_end_queries[net_Deferred_end_queries_count++] = query_id;
if (net_Deferred_end_queries_count < NET_DEFER_END_QUERIES_MAX)
{
/* Do not create a request for now. Defer it until NET_DEFER_END_QUERIES_MAX requests are collected or until
* commit/abort. */
return NO_ERROR;
}
assert (net_Deferred_end_queries_count == NET_DEFER_END_QUERIES_MAX);
net_Deferred_end_queries_count = 0;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_int (request, NET_DEFER_END_QUERIES_MAX);
for (i = 0; i < NET_DEFER_END_QUERIES_MAX; i++)
{
ptr = or_pack_ptr (ptr, net_Deferred_end_queries[i]);
}
assert (CAST_BUFLEN (ptr - request) <= (int) OR_ALIGNED_BUF_SIZE (a_request));
req_error =
net_client_request (NET_SERVER_QM_QUERY_END, request, CAST_BUFLEN (ptr - request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error == NO_ERROR)
{
or_unpack_int (reply, &status);
}
else
{
status = req_error;
}
return status;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xqmgr_end_query (thread_p, query_id);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* qm_query_drop_all_plan - Send a SERVER_QM_DROP_ALL_PLAN request to the server
*
* Request the server to clear all XASL cache entires out. When the client
* want to delete all cached query plans, this function will be used.
* This function is a counter part to sqmgr_drop_all_query_plans().
*/
/*
* qmgr_drop_all_query_plans -
*
* return:
*
* NOTE:
*/
int
qmgr_drop_all_query_plans (void)
{
#if defined(CS_MODE)
int status = ER_FAILED;
int req_error, request_size;
char *request, *reply;
OR_ALIGNED_BUF (OR_XASL_ID_SIZE) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
request = OR_ALIGNED_BUF_START (a_request);
request_size = OR_INT_SIZE;
reply = OR_ALIGNED_BUF_START (a_reply);
or_pack_int (request, 0); /* dummy parameter */
/* send SERVER_QM_QUERY_DROP_ALL_PLANS request with request data; receive status code (int) as a reply */
req_error =
net_client_request (NET_SERVER_QM_QUERY_DROP_ALL_PLANS, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
/* first argument should be status code (int) */
(void) or_unpack_int (reply, &status);
}
return status;
#else /* CS_MODE */
int status;
THREAD_ENTRY *thread_p = enter_server ();
/* call the server routine of query drop plan */
status = xqmgr_drop_all_query_plans (thread_p);
exit_server (*thread_p);
return status;
#endif /* !CS_MODE */
}
/*
* qmgr_drop_query_plans_by_sha1 - Send a SERVER_QM_DROP_BY_SHA1 request to the server
*
* Request the server to clear sha1 XASL cache entires out. When the client
* want to delete cached query plans for sha1, this function will be used.
* This function is a counter part to sqmgr_drop_all_query_plans().
*/
/*
* qmgr_drop_query_plans_by_sha1 -
*
* return:
*
* NOTE:
*/
int
qmgr_drop_query_plans_by_sha1 (char *sha1)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int request_size, strlen1;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
int req_error;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (sha1, &strlen1);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
pack_const_string_with_length (request, sha1, strlen1);
req_error = net_client_request (NET_SERVER_QM_QUERY_DROP_SHA1_PLANS, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &success);
}
free_and_init (request);
return success;
#else /* CS_MODE */
int status;
THREAD_ENTRY *thread_p = enter_server ();
/* call the server routine of query drop plan */
status = xqmgr_drop_query_plans_by_sha1 (thread_p, sha1);
exit_server (*thread_p);
return status;
#endif /* !CS_MODE */
}
/*
* qmgr_dump_query_plans -
*
* return:
*
* outfp(in):
*
* NOTE:
*/
void
qmgr_dump_query_plans (FILE * outfp)
{
#if defined(CS_MODE)
int req_error;
if (outfp == NULL)
{
outfp = stdout;
}
req_error = net_client_request_recv_stream (NET_SERVER_QM_QUERY_DUMP_PLANS, NULL, 0, NULL, 0, NULL, 0, outfp);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xqmgr_dump_query_plans (thread_p, outfp);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
/*
* qmgr_dump_query_cache -
*
* return:
*
* outfp(in):
*
* NOTE:
*/
void
qmgr_dump_query_cache (FILE * outfp)
{
#if defined(CS_MODE)
int req_error;
if (outfp == NULL)
{
outfp = stdout;
}
req_error = net_client_request_recv_stream (NET_SERVER_QM_QUERY_DUMP_CACHE, NULL, 0, NULL, 0, NULL, 0, outfp);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xqmgr_dump_query_cache (thread_p, outfp);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
#if defined(ENABLE_UNUSED_FUNCTION)
/*
* qp_get_sys_timestamp -
*
* return:
*
* value(in):
*
* NOTE:
*/
int
qp_get_sys_timestamp (DB_VALUE * value)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_UTIME_SIZE) a_reply;
char *reply;
DB_TIMESTAMP sysutime;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_QPROC_GET_SYS_TIMESTAMP, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_utime (reply, &sysutime);
db_make_timestamp (value, sysutime);
}
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
db_sys_timestamp (value);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
#endif /* ENABLE_UNUSED_FUNCTION */
/*
* serial_get_current_value -
*
* return:
*
* value(in):
* oid(in):
*
* NOTE:
*/
int
serial_get_current_value (DB_VALUE * value, OID * oid_p, int cached_num)
{
#if defined(CS_MODE)
int req_error, error = ER_NET_CLIENT_DATA_RECEIVE;
char *request, *area = NULL;
int area_size;
OR_ALIGNED_BUF (OR_OID_SIZE + OR_INT_SIZE) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply, *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, oid_p);
ptr = or_pack_int (ptr, cached_num);
req_error =
net_client_request2 (NET_SERVER_QPROC_GET_CURRENT_VALUE, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (!req_error && area != NULL)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error);
(void) or_unpack_value (area, value);
free_and_init (area);
}
return error;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
error = xserial_get_current_value (thread_p, value, oid_p, cached_num);
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* serial_get_next_value -
*
* return:
*
* value(in):
* oid(in):
*
* NOTE:
*/
int
serial_get_next_value (DB_VALUE * value, OID * oid_p, int cached_num, int num_alloc, int is_auto_increment)
{
#if defined(CS_MODE)
int req_error, error = ER_NET_CLIENT_DATA_RECEIVE;
char *request, *area = NULL;
int area_size;
OR_ALIGNED_BUF (OR_OID_SIZE + (OR_INT_SIZE * 3)) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply, *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, oid_p);
ptr = or_pack_int (ptr, cached_num);
ptr = or_pack_int (ptr, num_alloc);
ptr = or_pack_int (ptr, is_auto_increment);
req_error =
net_client_request2 (NET_SERVER_QPROC_GET_NEXT_VALUE, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (!req_error && area != NULL)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error);
(void) or_unpack_value (area, value);
free_and_init (area);
}
return error;
#else /* CS_MODE */
int error;
THREAD_ENTRY *thread_p = enter_server ();
/*
* If a client wants to generate AUTO_INCREMENT value during client-side
* insertion, a server should update LAST_INSERT_ID on a session.
*/
error = xserial_get_next_value (thread_p, value, oid_p, cached_num, num_alloc, is_auto_increment, true);
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* serial_decache -
*
* return: NO_ERROR or error status
*
* oid(in):
*
* NOTE:
*/
int
serial_decache (OID * oid)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_OID_SIZE) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply; /* need dummy reply message */
char *request;
char *reply;
int status;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
or_pack_oid (request, oid);
req_error =
net_client_request (NET_SERVER_SERIAL_DECACHE, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xserial_decache (thread_p, oid);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* synonym_remove_xasl_by_oid -
*
* return: NO_ERROR or error status
*
* oid(in):
*
* NOTE:
*/
int
synonym_remove_xasl_by_oid (OID * oid)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_OID_SIZE) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply; /* need dummy reply message */
char *request;
char *reply;
int status;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
assert (oid != NULL);
or_pack_oid (request, oid);
req_error =
net_client_request (NET_SERVER_SYNONYM_REMOVE_XASL_BY_OID, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
assert (oid != NULL);
xsynonym_remove_xasl_by_oid (thread_p, oid);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* perfmon_server_start_stats -
*
* return:
*
* NOTE:
*/
int
perfmon_server_start_stats (void)
{
#if defined(CS_MODE)
int status = ER_FAILED;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_MNT_SERVER_START_STATS, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &status);
}
return (status);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
perfmon_start_watch (thread_p);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* perfmon_server_stop_stats -
*
* return:
*
* NOTE:
*/
int
perfmon_server_stop_stats (void)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply; /* need dummy reply message */
char *reply;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_MNT_SERVER_STOP_STATS, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply),
NULL, 0, NULL, 0);
if (!req_error)
{
return ER_FAILED;
}
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
perfmon_stop_watch (thread_p);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* perfmon_server_copy_stats -
*
* return:
*
* to_stats(in):
*
* NOTE:
*/
int
perfmon_server_copy_stats (UINT64 * to_stats)
{
#if defined(CS_MODE)
int req_error = NO_ERROR;
char *reply;
int nr_statistic_values;
nr_statistic_values = perfmon_get_number_of_statistic_values ();
reply = (char *) malloc (nr_statistic_values * OR_INT64_SIZE);
if (reply == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
(size_t) nr_statistic_values * OR_INT64_SIZE);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
req_error =
net_client_request (NET_SERVER_MNT_SERVER_COPY_STATS, NULL, 0, reply,
nr_statistic_values * OR_INT64_SIZE, NULL, 0, NULL, 0);
if (!req_error)
{
perfmon_unpack_stats (reply, to_stats);
}
else
{
perfmon_Iscollecting_stats = false;
}
free_and_init (reply);
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xperfmon_server_copy_stats (thread_p, to_stats, true);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* perfmon_server_copy_global_stats -
*
* return:
*
* to_stats(in):
*
* NOTE:
*/
int
perfmon_server_copy_global_stats (UINT64 * to_stats)
{
#if defined(CS_MODE)
int req_error = NO_ERROR;
char *reply = NULL;
int nr_statistic_values;
nr_statistic_values = perfmon_get_number_of_statistic_values ();
reply = (char *) malloc (nr_statistic_values * OR_INT64_SIZE);
if (reply == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1,
(size_t) nr_statistic_values * OR_INT64_SIZE);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
req_error = net_client_request (NET_SERVER_MNT_SERVER_COPY_GLOBAL_STATS, NULL, 0, reply,
nr_statistic_values * OR_INT64_SIZE, NULL, 0, NULL, 0);
if (!req_error)
{
perfmon_unpack_stats (reply, to_stats);
}
else
{
perfmon_Iscollecting_stats = false;
}
free_and_init (reply);
return req_error;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xperfmon_server_copy_global_stats (to_stats);
exit_server (*thread_p);
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* catalog_check_rep_dir -
*
* return:
*
* class_id(in):
* rep_dir_p(out):
*
* NOTE:
*/
int
catalog_check_rep_dir (OID * class_id, OID * rep_dir_p)
{
#if defined(CS_MODE)
int req_error, status;
OR_ALIGNED_BUF (OR_OID_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_OID_SIZE) a_reply;
char *reply;
char *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, class_id);
req_error =
net_client_request (NET_SERVER_CT_CHECK_REP_DIR, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error)
{
status = ER_FAILED;
}
else
{
ptr = or_unpack_int (reply, &status);
ptr = or_unpack_oid (ptr, rep_dir_p);
}
return status;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xcatalog_check_rep_dir (thread_p, class_id, rep_dir_p);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* thread_kill_tran_index -
*
* return:
*
* kill_tran_index(in):
* kill_user(in):
* kill_host(in):
* kill_pid(in):
*
* NOTE:
*/
int
thread_kill_tran_index (int kill_tran_index, char *kill_user, char *kill_host, int kill_pid)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int request_size, strlen1, strlen2;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply, *ptr;
int req_error;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = (OR_INT_SIZE + OR_INT_SIZE + length_const_string (kill_user, &strlen1)
+ length_const_string (kill_host, &strlen2));
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = or_pack_int (request, kill_tran_index);
ptr = pack_const_string_with_length (ptr, kill_user, strlen1);
ptr = pack_const_string_with_length (ptr, kill_host, strlen2);
ptr = or_pack_int (ptr, kill_pid);
req_error = net_client_request (NET_SERVER_CSS_KILL_TRANSACTION, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &success);
}
free_and_init (request);
return success;
#else /* CS_MODE */
er_log_debug (ARG_FILE_LINE, "css_kill_client: THIS IS ONLY a C/S function");
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* thread_kill_or_interrupt_tran -
*
* return:
*
* tran_index_list(in):
* num_tran_index(in):
* is_dba_group_member(in):
* interrupt_only(in):
* num_killed(out):
*
* NOTE:
*/
int
thread_kill_or_interrupt_tran (int *tran_index_list, int num_tran_index, bool is_dba_group_member, bool interrupt_only,
int *num_killed)
{
#if defined(CS_MODE)
int success = ER_FAILED;
int request_size;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply, *ptr;
int req_error;
int i;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = OR_INT_SIZE * (2 + num_tran_index); /* num_tran_index + tran_index_list + interrupt_only */
request_size += OR_INT_SIZE; /* is_dba_group_member */
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = or_pack_int (request, (int) is_dba_group_member);
ptr = or_pack_int (ptr, num_tran_index);
for (i = 0; i < num_tran_index; i++)
{
ptr = or_pack_int (ptr, tran_index_list[i]);
}
ptr = or_pack_int (ptr, (interrupt_only) ? 1 : 0);
req_error =
net_client_request (NET_SERVER_CSS_KILL_OR_INTERRUPT_TRANSACTION, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
ptr = or_unpack_int (ptr, num_killed);
}
free_and_init (request);
return success;
#else /* CS_MODE */
er_log_debug (ARG_FILE_LINE, "thread_kill_or_interrupt_tran: THIS IS ONLY a C/S function");
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* thread_dump_cs_stat -
*
* return:
*
* outfp(in):
*/
void
thread_dump_cs_stat (FILE * outfp)
{
#if defined(CS_MODE)
int req_error;
if (outfp == NULL)
{
outfp = stdout;
}
req_error = net_client_request_recv_stream (NET_SERVER_CSS_DUMP_CS_STAT, NULL, 0, NULL, 0, NULL, 0, outfp);
#else /* CS_MODE */
er_log_debug (ARG_FILE_LINE, "thread_dump_cs_stat: THIS IS ONLY a C/S function");
return;
#endif /* !CS_MODE */
}
/*
* logtb_get_pack_tran_table -
*
* return:
*
* buffer_p(in):
* size_p(in):
* include_query_exec_info(in):
*
* NOTE:
*/
int
logtb_get_pack_tran_table (char **buffer_p, int *size_p, bool include_query_exec_info)
{
#if defined(CS_MODE)
int error = NO_ERROR;
int req_error;
int ival;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request = OR_ALIGNED_BUF_START (a_request);
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
char *ptr;
/* --query-exec-info */
or_pack_int (request, ((include_query_exec_info) ? 1 : 0));
req_error =
net_client_request2 (NET_SERVER_LOG_GETPACK_TRANTB, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, buffer_p, size_p);
if (req_error)
{
assert (er_errid () != NO_ERROR);
error = er_errid ();
}
else
{
/* first word is buffer size, second is error code */
ptr = reply;
ptr = or_unpack_int (ptr, &ival);
ptr = or_unpack_int (ptr, &ival);
error = (int) ival;
}
return error;
#else /* CS_MODE */
int error;
THREAD_ENTRY *thread_p = enter_server ();
error = xlogtb_get_pack_tran_table (thread_p, buffer_p, size_p, 0);
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* logtb_free_trans_info - Free transaction table information
* return: none
* info(in): TRANS_INFO to be freed
*/
void
logtb_free_trans_info (TRANS_INFO * info)
{
int i;
if (info == NULL)
{
return;
}
for (i = 0; i < info->num_trans; i++)
{
if (info->tran[i].db_user != NULL)
{
db_private_free_and_init (NULL, info->tran[i].db_user);
}
if (info->tran[i].program_name != NULL)
{
db_private_free_and_init (NULL, info->tran[i].program_name);
}
if (info->tran[i].login_name != NULL)
{
db_private_free_and_init (NULL, info->tran[i].login_name);
}
if (info->tran[i].host_name != NULL)
{
db_private_free_and_init (NULL, info->tran[i].host_name);
}
if (info->include_query_exec_info)
{
if (info->tran[i].query_exec_info.query_stmt)
{
db_private_free_and_init (NULL, info->tran[i].query_exec_info.query_stmt);
}
if (info->tran[i].query_exec_info.wait_for_tran_index_string)
{
db_private_free_and_init (NULL, info->tran[i].query_exec_info.wait_for_tran_index_string);
}
if (info->tran[i].query_exec_info.sql_id)
{
db_private_free_and_init (NULL, info->tran[i].query_exec_info.sql_id);
}
}
else
{
assert_release (info->tran[i].query_exec_info.query_stmt == NULL);
assert_release (info->tran[i].query_exec_info.wait_for_tran_index_string == NULL);
}
}
free_and_init (info);
}
/*
* logtb_get_trans_info - Get transaction table information which identifies
* active transactions
* include_query_exec_info(in) :
* return: TRANS_INFO array or NULL
*/
TRANS_INFO *
logtb_get_trans_info (bool include_query_exec_info)
{
TRANS_INFO *info = NULL;
char *buffer, *ptr;
int num_trans, bufsize, i;
int error;
error = logtb_get_pack_tran_table (&buffer, &bufsize, include_query_exec_info);
if (error != NO_ERROR || buffer == NULL)
{
return NULL;
}
ptr = buffer;
ptr = or_unpack_int (ptr, &num_trans);
if (num_trans == 0)
{
/* can't happen, there must be at least one transaction */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_GENERIC_ERROR, 0);
goto error;
}
i = sizeof (TRANS_INFO) + ((num_trans - 1) * sizeof (ONE_TRAN_INFO));
info = (TRANS_INFO *) malloc (i);
if (info == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) i);
goto error;
}
memset (info, '\0', i);
info->num_trans = num_trans;
info->include_query_exec_info = include_query_exec_info;
for (i = 0; i < num_trans; i++)
{
int unpack_int_value;
ptr = or_unpack_int (ptr, &info->tran[i].tran_index);
ptr = or_unpack_int (ptr, &unpack_int_value);
info->tran[i].state = (TRAN_STATE) unpack_int_value;
ptr = or_unpack_int (ptr, &info->tran[i].process_id);
ptr = or_unpack_string (ptr, &info->tran[i].db_user);
ptr = or_unpack_string (ptr, &info->tran[i].program_name);
ptr = or_unpack_string (ptr, &info->tran[i].login_name);
ptr = or_unpack_string (ptr, &info->tran[i].host_name);
if (ptr == NULL)
{
assert (false);
goto error;
}
if (include_query_exec_info)
{
ptr = or_unpack_float (ptr, &info->tran[i].query_exec_info.query_time);
ptr = or_unpack_float (ptr, &info->tran[i].query_exec_info.tran_time);
ptr = or_unpack_string (ptr, &info->tran[i].query_exec_info.wait_for_tran_index_string);
ptr = or_unpack_string (ptr, &info->tran[i].query_exec_info.query_stmt);
ptr = or_unpack_string (ptr, &info->tran[i].query_exec_info.sql_id);
if (ptr == NULL)
{
assert (false);
goto error;
}
OR_UNPACK_XASL_ID (ptr, &info->tran[i].query_exec_info.xasl_id);
}
}
if (((int) (ptr - buffer)) != bufsize)
{
/* unpacking didn't match size, garbage */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_GENERIC_ERROR, 0);
goto error;
}
free_and_init (buffer);
return info;
error:
if (buffer != NULL)
{
free_and_init (buffer);
}
if (info != NULL)
{
logtb_free_trans_info (info);
}
return NULL;
}
/*
* logtb_dump_trantable -
*
* return:
*
* outfp(in):
*/
void
logtb_dump_trantable (FILE * outfp)
{
#if defined(CS_MODE)
int req_error;
if (outfp == NULL)
{
outfp = stdout;
}
req_error = net_client_request_recv_stream (NET_SERVER_LOG_DUMP_TRANTB, NULL, 0, NULL, 0, NULL, 0, outfp);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xlogtb_dump_trantable (thread_p, outfp);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
/*
* btree_get_statistics -
*
* return:
*
* btid(in):
* stat_info(in):
*
* NOTE:
*/
int
btree_get_statistics (BTID * btid, BTREE_STATS * stat_info)
{
#if defined(CS_MODE)
int req_error, status = ER_FAILED;
OR_ALIGNED_BUF (OR_BTID_ALIGNED_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE * 5) a_reply;
char *reply;
char *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_btid (request, btid);
req_error =
net_client_request (NET_SERVER_BTREE_GET_STATISTICS, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &status);
ptr = or_unpack_int (ptr, &stat_info->leafs);
ptr = or_unpack_int (ptr, &stat_info->pages);
ptr = or_unpack_int (ptr, &stat_info->height);
ptr = or_unpack_int (ptr, &stat_info->keys);
assert_release (stat_info->leafs > 0);
assert_release (stat_info->pages > 0);
assert_release (stat_info->height > 0);
assert_release (stat_info->keys >= 0);
}
return status;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
assert_release (!BTID_IS_NULL (btid));
assert_release (stat_info->keys == 0);
assert_release (stat_info->pkeys_size == 0);
assert_release (stat_info->pkeys == NULL);
BTID_COPY (&stat_info->btid, btid);
if (stat_info->pkeys_size != 0)
{
stat_info->pkeys_size = 0; /* do not request pkeys info */
}
success = btree_get_stats (thread_p, stat_info, STATS_WITH_SAMPLING);
assert_release (stat_info->leafs > 0);
assert_release (stat_info->pages > 0);
assert_release (stat_info->height > 0);
assert_release (stat_info->keys >= 0);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* btree_get_index_key_type () - Get index key type.
*
* return : Error code.
* btid (in) : Index b-tree identifier.
* key_type_p (out) : Index key type.
*/
int
btree_get_index_key_type (BTID btid, TP_DOMAIN ** key_type_p)
{
#if defined(CS_MODE)
int error;
OR_ALIGNED_BUF (OR_BTID_ALIGNED_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply = NULL;
char *ptr = NULL;
char *reply_data = NULL;
int reply_data_size = 0;
int dummy;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
/* Send BTID to server */
ptr = or_pack_btid (request, &btid);
error =
net_client_request2 (NET_SERVER_BTREE_GET_KEY_TYPE, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &reply_data, &reply_data_size);
if (error != NO_ERROR)
{
return error;
}
ptr = or_unpack_int (reply, &reply_data_size);
ptr = or_unpack_int (ptr, &error);
if (error != NO_ERROR)
{
return error;
}
if (reply_data != NULL)
{
/* Obtain key type from server */
(void) or_unpack_domain (reply_data, key_type_p, &dummy);
}
free_and_init (reply_data);
return error;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
assert_release (!BTID_IS_NULL (&btid));
assert_release (key_type_p != NULL);
error = xbtree_get_key_type (thread_p, btid, key_type_p);
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* db_local_transaction_id -
*
* return:
*
* result_trid(in):
*
* NOTE:
*/
int
db_local_transaction_id (DB_VALUE * result_trid)
{
#if defined(CS_MODE)
int req_error, trid = 0;
int success = ER_FAILED;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply, *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_TM_LOCAL_TRANSACTION_ID, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
ptr = or_unpack_int (ptr, &trid);
}
db_make_int (result_trid, trid);
return success;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xtran_get_local_transaction_id (thread_p, result_trid);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* qp_get_server_info -
*
* return:
*
* server_info(in):
*
* NOTE:
*/
int
qp_get_server_info (PARSER_CONTEXT * parser, int server_info_bits)
{
#if defined(CS_MODE)
int status = ER_FAILED;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply;
char *ptr, *area = NULL;
int val_size;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_int (request, server_info_bits);
status =
net_client_request2 (NET_SERVER_QPROC_GET_SERVER_INFO, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &val_size);
if (status != NO_ERROR)
{
goto error_exit;
}
if (area != NULL)
{
ptr = or_unpack_int (reply, &val_size);
ptr = or_unpack_int (ptr, &status);
if (status != NO_ERROR)
{
goto error_exit;
}
ptr = area;
if (server_info_bits & SI_SYS_DATETIME)
{
ptr = or_unpack_value (ptr, &(parser->sys_datetime));
ptr = or_unpack_value (ptr, &(parser->sys_epochtime));
}
if (server_info_bits & SI_LOCAL_TRANSACTION_ID)
{
ptr = or_unpack_value (ptr, &parser->local_transaction_id);
}
}
error_exit:
if (area != NULL)
{
free_and_init (area);
}
return status;
#else /* CS_MODE */
int success = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
if (server_info_bits & SI_SYS_DATETIME)
{
success = db_sys_date_and_epoch_time (&(parser->sys_datetime), &(parser->sys_epochtime));
if (success != NO_ERROR)
{
goto error_exit;
}
}
if (server_info_bits & SI_LOCAL_TRANSACTION_ID)
{
success = db_local_transaction_id (&parser->local_transaction_id);
}
error_exit:
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* sysprm_change_server_parameters () - Sends a list of assignments to server in order to change system parameter
* values.
*
* return : SYSPRM_ERR code.
* assignments (in) : list of assignments.
*/
SYSPRM_ERR
sysprm_change_server_parameters (const SYSPRM_ASSIGN_VALUE * assignments)
{
#if defined(CS_MODE)
SYSPRM_ERR rc = PRM_ERR_COMM_ERR;
int request_size = 0, req_error = NO_ERROR;
char *request = NULL, *reply = NULL;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = sysprm_packed_assign_values_length (assignments, 0);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return PRM_ERR_NO_MEM_FOR_PRM;
}
(void) sysprm_pack_assign_values (request, assignments);
req_error =
net_client_request (NET_SERVER_PRM_SET_PARAMETERS, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error == NO_ERROR)
{
int unpack_value;
or_unpack_int (reply, &unpack_value);
rc = (SYSPRM_ERR) unpack_value;
}
else
{
rc = PRM_ERR_COMM_ERR;
}
free_and_init (request);
return rc;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xsysprm_change_server_parameters (assignments);
exit_server (*thread_p);
return PRM_ERR_NO_ERROR;
#endif /* !CS_MODE */
}
/*
* sysprm_obtain_server_parameters () - Obtain values for system parameters from server.
*
* return : SYSPRM_ERR code.
* prm_values_ptr (in/out) : list of parameter values.
*/
SYSPRM_ERR
sysprm_obtain_server_parameters (SYSPRM_ASSIGN_VALUE ** prm_values_ptr)
{
#if defined(CS_MODE)
SYSPRM_ERR rc = PRM_ERR_COMM_ERR;
int req_error = NO_ERROR, request_size = 0, receive_size = 0;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply = NULL, *request_data = NULL, *receive_data = NULL;
char *ptr = NULL;
SYSPRM_ASSIGN_VALUE *updated_prm_values = NULL;
assert (prm_values_ptr != NULL && *prm_values_ptr != NULL);
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = sysprm_packed_assign_values_length (*prm_values_ptr, 0);
request_data = (char *) malloc (request_size);
if (request_data == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return PRM_ERR_NO_MEM_FOR_PRM;
}
(void) sysprm_pack_assign_values (request_data, *prm_values_ptr);
req_error =
net_client_request2 (NET_SERVER_PRM_GET_PARAMETERS, request_data, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &receive_data, &receive_size);
if (req_error != NO_ERROR)
{
rc = PRM_ERR_COMM_ERR;
}
else
{
int unpack_value;
ptr = or_unpack_int (reply, &receive_size);
ptr = or_unpack_int (ptr, &unpack_value);
rc = (SYSPRM_ERR) unpack_value;
if (rc != PRM_ERR_NO_ERROR || receive_data == NULL)
{
goto cleanup;
}
(void) sysprm_unpack_assign_values (receive_data, &updated_prm_values);
/* free old values */
sysprm_free_assign_values (prm_values_ptr);
/* update values */
*prm_values_ptr = updated_prm_values;
}
cleanup:
if (request_data != NULL)
{
free_and_init (request_data);
}
if (receive_data != NULL)
{
free_and_init (receive_data);
}
return rc;
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xsysprm_obtain_server_parameters (*prm_values_ptr);
exit_server (*thread_p);
return PRM_ERR_NO_ERROR;
#endif /* !CS_MODE */
}
/*
* sysprm_get_force_server_parameters () - Get from server values for system parameters marked with
* PRM_FORCE_SERVER flag.
*
* return : error code
* change_values (out) : list of parameter values.
*/
int
sysprm_get_force_server_parameters (SYSPRM_ASSIGN_VALUE ** change_values)
{
#if defined (CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
int area_size, error;
char *reply = NULL, *area = NULL, *ptr = NULL;
assert (change_values != NULL);
*change_values = NULL;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request2 (NET_SERVER_PRM_GET_FORCE_PARAMETERS, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (req_error != NO_ERROR)
{
error = req_error;
goto error;
}
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error);
if (error != NO_ERROR)
{
goto error;
}
if (area != NULL)
{
(void) sysprm_unpack_assign_values (area, change_values);
free_and_init (area);
}
return NO_ERROR;
error:
if (area != NULL)
{
free_and_init (area);
}
return error;
#else /* CS_MODE */
assert (change_values != NULL);
*change_values = NULL;
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* sysprm_dump_server_parameters -
*
* return:
*/
void
sysprm_dump_server_parameters (FILE * outfp, unsigned int in_flags, SYSPRM_DUMP_CONDITION if_cond,
unsigned int out_flags, SYSPRM_DUMP_CONDITION of_cond, bool old_style)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE * 5) a_request;
char *ptr, *request;
if (outfp == NULL)
{
outfp = stdout;
}
request = OR_ALIGNED_BUF_START (a_request);
ptr = or_pack_int (request, in_flags);
ptr = or_pack_int (ptr, if_cond);
ptr = or_pack_int (ptr, out_flags);
ptr = or_pack_int (ptr, of_cond);
ptr = or_pack_int (ptr, old_style);
req_error =
net_client_request_recv_stream (NET_SERVER_PRM_DUMP_PARAMETERS, request,
OR_ALIGNED_BUF_SIZE (a_request), NULL, 0, NULL, 0, outfp);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xsysprm_dump_server_parameters (outfp, in_flags, if_cond, out_flags, of_cond, old_style);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
/*
* pl_get_server_port -
*
* return:
*
* NOTE:
*/
int
pl_get_server_port (void)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
int port = -1;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_JSP_GET_SERVER_PORT, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &port);
}
return port;
#else /* CS_MODE */
int port;
THREAD_ENTRY *thread_p = enter_server ();
port = pl_server_port_from_info ();
exit_server (*thread_p);
return port;
#endif /* !CS_MODE */
}
/*
* repl_log_get_append_lsa -
*
* return:
*
* lsa(in):
*
* NOTE:
*/
int
repl_log_get_append_lsa (LOG_LSA * lsa)
{
#if defined(CS_MODE)
int req_error, success = ER_FAILED;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_LOG_LSA_ALIGNED_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_REPL_LOG_GET_APPEND_LSA, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_log_lsa (reply, lsa);
success = NO_ERROR;
}
return success;
#else /* CS_MODE */
LOG_LSA *tmp_lsa = NULL;
int r = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
tmp_lsa = xrepl_log_get_append_lsa ();
if (lsa && tmp_lsa)
{
LSA_COPY (lsa, tmp_lsa);
r = NO_ERROR;
}
else
{
r = ER_FAILED;
}
exit_server (*thread_p);
return r;
#endif /* !CS_MODE */
}
/*
* repl_set_info -
*
* return:
*
* repl_info(in):
*
* NOTE:
*/
int
repl_set_info (REPL_INFO * repl_info)
{
#if defined(CS_MODE)
int req_error, success = ER_FAILED;
int request_size = 0, strlen1, strlen2, strlen3, strlen4;
char *request = NULL, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
REPL_INFO_SBR *repl_schema;
reply = OR_ALIGNED_BUF_START (a_reply);
switch (repl_info->repl_info_type)
{
case REPL_INFO_TYPE_SBR:
repl_schema = (REPL_INFO_SBR *) repl_info->info;
request_size = (OR_INT_SIZE /* REPL_INFO.REPL_INFO_TYPE */
+ OR_INT_SIZE /* REPL_INFO_SCHEMA.statement_type */
+ length_const_string (repl_schema->name, &strlen1)
+ length_const_string (repl_schema->stmt_text, &strlen2)
+ length_const_string (repl_schema->db_user, &strlen3)
+ length_const_string (repl_schema->sys_prm_context, &strlen4));
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = or_pack_int (request, REPL_INFO_TYPE_SBR);
ptr = or_pack_int (ptr, repl_schema->statement_type);
ptr = pack_const_string_with_length (ptr, repl_schema->name, strlen1);
ptr = pack_const_string_with_length (ptr, repl_schema->stmt_text, strlen2);
ptr = pack_const_string_with_length (ptr, repl_schema->db_user, strlen3);
ptr = pack_const_string_with_length (ptr, repl_schema->sys_prm_context, strlen4);
req_error =
net_client_request (NET_SERVER_REPL_INFO, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &success);
}
free_and_init (request);
break;
default:
break;
}
return success;
#else /* CS_MODE */
int r = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
r = xrepl_set_info (thread_p, repl_info);
exit_server (*thread_p);
return r;
#endif /* !CS_MODE */
}
/*
* locator_check_fk_validity -
*
* return:
*
* cls_oid(in):
* hfid(in):
* key_type(in):
* n_attrs(in):
* attr_ids(in):
* pk_cls_oid(in):
* pk_btid(in):
* fk_name(in):
*
* NOTE:
*/
int
locator_check_fk_validity (OID * cls_oid, HFID * hfid, TP_DOMAIN * key_type, int n_attrs, int *attr_ids,
OID * pk_cls_oid, BTID * pk_btid, char *fk_name)
{
#if defined(CS_MODE)
int error, req_error, request_size, domain_size;
char *ptr;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
int i, strlen;
error = NO_ERROR;
reply = OR_ALIGNED_BUF_START (a_reply);
domain_size = or_packed_domain_size (key_type, 0);
request_size = (OR_OID_SIZE + OR_HFID_SIZE + domain_size + OR_INT_SIZE + (n_attrs * OR_INT_SIZE)
+ OR_OID_SIZE + OR_BTID_ALIGNED_SIZE + or_packed_string_length (fk_name, &strlen));
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = or_pack_oid (request, cls_oid);
ptr = or_pack_hfid (ptr, hfid);
ptr = or_pack_domain (ptr, key_type, 0, 0);
ptr = or_pack_int (ptr, n_attrs);
for (i = 0; i < n_attrs; i++)
{
ptr = or_pack_int (ptr, attr_ids[i]);
}
ptr = or_pack_oid (ptr, pk_cls_oid);
ptr = or_pack_btid (ptr, pk_btid);
ptr = or_pack_string_with_length (ptr, fk_name, strlen);
req_error = net_client_request (NET_SERVER_LC_CHECK_FK_VALIDITY, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &error);
}
else
{
error = req_error;
}
free_and_init (request);
return error;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
error =
xlocator_check_fk_validity (thread_p, cls_oid, hfid, key_type, n_attrs, attr_ids, pk_cls_oid, pk_btid, fk_name);
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* logwr_get_log_pages -
*
* return:
*
* rc_ptr(in/out): request context
*
* NOTE:
*/
int
logwr_get_log_pages (LOGWR_CONTEXT * ctx_ptr)
{
#if defined(CS_MODE)
OR_ALIGNED_BUF (OR_INT64_SIZE + OR_INT_SIZE * 2) a_request;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *request, *reply;
char *ptr;
LOG_PAGEID first_pageid_torecv;
LOGWR_MODE mode, save_mode;
int req_error, error = NO_ERROR;
/* Do it as async mode at the first request to the server. And, if several pages are left to get, keep it as async
* mode */
assert (logwr_Gl.last_recv_pageid <= logwr_Gl.hdr.eof_lsa.pageid);
if (logwr_Gl.last_recv_pageid == logwr_Gl.hdr.eof_lsa.pageid)
{
/* In case of synchronous request */
first_pageid_torecv = logwr_Gl.last_recv_pageid;
mode = (logwr_Gl.last_recv_pageid == NULL_PAGEID) ? LOGWR_MODE_ASYNC : logwr_Gl.mode;
}
else
{
/* In the middle of sending the pages which are already flushed */
if (logwr_Gl.last_recv_pageid == NULL_PAGEID)
{
/* To check database equality at first, get the header page */
first_pageid_torecv = LOGPB_HEADER_PAGE_ID;
}
else
{
/* When it overtakes the state of the server, it set ha_file_state is sync'ed. And, the flush action is not
* sync'ed with the server. So, it requests the last page again to get the missing log records. */
if (logwr_Gl.hdr.ha_file_status == LOG_HA_FILESTAT_SYNCHRONIZED)
{
first_pageid_torecv = logwr_Gl.last_recv_pageid;
}
else
{
first_pageid_torecv = logwr_Gl.last_recv_pageid + 1;
}
}
/* In case of archiving, not replication delay */
if (first_pageid_torecv == logwr_Gl.ori_nxarv_pageid)
{
mode = logwr_Gl.mode;
}
else
{
mode = LOGWR_MODE_ASYNC;
}
}
er_log_debug (ARG_FILE_LINE, "logwr_get_log_pages, fpageid(%lld), mode(%s)", first_pageid_torecv,
mode == LOGWR_MODE_SYNC ? "sync" : (mode == LOGWR_MODE_ASYNC ? "async" : "semisync"));
save_mode = logwr_Gl.mode;
logwr_Gl.mode = mode;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
if (first_pageid_torecv == NULL_PAGEID && logwr_Gl.start_pageid >= NULL_PAGEID)
{
ptr = or_pack_int64 (request, logwr_Gl.start_pageid);
mode = (LOGWR_MODE) (mode | LOGWR_COPY_FROM_FIRST_PHY_PAGE_MASK);
}
else
{
ptr = or_pack_int64 (request, first_pageid_torecv);
}
ptr = or_pack_int (ptr, mode);
ptr = or_pack_int (ptr, ctx_ptr->last_error);
req_error =
net_client_request_with_logwr_context (ctx_ptr, NET_SERVER_LOGWR_GET_LOG_PAGES, request,
OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
logwr_Gl.mode = save_mode;
if (req_error != NO_ERROR)
{
error = req_error;
if (error == ER_NET_SERVER_CRASHED)
{
if (logwr_Gl.mode == LOGWR_MODE_SEMISYNC)
{
logwr_Gl.force_flush = true;
logwr_write_log_pages ();
}
/* Write the server is dead at the log header */
logwr_Gl.hdr.ha_server_state = HA_SERVER_STATE_DEAD;
logwr_flush_header_page ();
ctx_ptr->shutdown = true;
}
else if (error == ER_HA_LW_FAILED_GET_LOG_PAGE)
{
if (logwr_Gl.mode == LOGWR_MODE_SEMISYNC)
{
logwr_Gl.force_flush = true;
logwr_write_log_pages ();
}
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, error, 1, first_pageid_torecv);
ctx_ptr->shutdown = true;
}
}
if (logwr_Gl.start_pageid >= NULL_PAGEID && logwr_Gl.hdr.eof_lsa.pageid == logwr_Gl.hdr.append_lsa.pageid
&& logwr_Gl.hdr.ha_file_status == LOG_HA_FILESTAT_SYNCHRONIZED)
{
ctx_ptr->shutdown = true;
error = NO_ERROR;
}
return error;
#else /* CS_MODE */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_NOT_IN_STANDALONE, 1, "copylog database");
return ER_NOT_IN_STANDALONE;
#endif /* !CS_MODE */
}
/*
* boot_compact_classes () - compact specified classes
*
* return : NO_ERROR if all OK, ER_ status otherwise
*
* class_oids(in): the class oids list to process
* n_classes(in): the length of class_oids
* space_to_process(in): the maximum space to process
* instance_lock_timeout(in): the lock timeout for instances
* class_lock_timeout(in): the lock timeout for classes
* delete_old_repr(in): true if old class representations must be deleted
* last_processed_class_oid(in,out): last processed class oid
* last_processed_oid(in,out): last processed oid
* total_objects(in,out): count processed objects for each class
* failed_objects(in,out): count failed objects for each class
* modified_objects(in,out): count modified objects for each class
* big_objects(in,out): count big objects for each class
* initial_last_repr_id(in,out): the list of last class representation
*
* Note:
*/
int
boot_compact_classes (OID ** class_oids, int num_classes, int space_to_process, int instance_lock_timeout,
int class_lock_timeout, bool delete_old_repr, OID * last_processed_class_oid,
OID * last_processed_oid, int *total_objects, int *failed_objects, int *modified_objects,
int *big_objects, int *ids_repr)
{
#if defined(CS_MODE)
int success = ER_FAILED, request_size, req_error, i, reply_size;
char *reply = NULL, *request = NULL, *ptr = NULL;
if (class_oids == NULL || num_classes < 0 || space_to_process < 0 || last_processed_class_oid == NULL
|| last_processed_oid == NULL || total_objects == NULL || failed_objects == NULL || modified_objects == NULL
|| big_objects == NULL || ids_repr == NULL)
{
return ER_QPROC_INVALID_PARAMETER;
}
request_size = OR_OID_SIZE * (num_classes + 2) + OR_INT_SIZE * (5 * num_classes + 5);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
reply_size = OR_OID_SIZE * 2 + OR_INT_SIZE * (5 * num_classes + 1);
reply = (char *) malloc (reply_size);
if (reply == NULL)
{
free_and_init (request);
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) reply_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = or_pack_int (request, num_classes);
for (i = 0; i < num_classes; i++)
{
ptr = or_pack_oid (ptr, class_oids[i]);
}
ptr = or_pack_int (ptr, space_to_process);
ptr = or_pack_int (ptr, instance_lock_timeout);
ptr = or_pack_int (ptr, class_lock_timeout);
ptr = or_pack_int (ptr, (int) delete_old_repr);
ptr = or_pack_oid (ptr, last_processed_class_oid);
ptr = or_pack_oid (ptr, last_processed_oid);
for (i = 0; i < num_classes; i++)
{
ptr = or_pack_int (ptr, total_objects[i]);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_pack_int (ptr, failed_objects[i]);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_pack_int (ptr, modified_objects[i]);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_pack_int (ptr, big_objects[i]);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_pack_int (ptr, ids_repr[i]);
}
req_error = net_client_request (NET_SERVER_BO_COMPACT_DB, request, request_size, reply, reply_size, NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
ptr = or_unpack_oid (ptr, last_processed_class_oid);
ptr = or_unpack_oid (ptr, last_processed_oid);
for (i = 0; i < num_classes; i++)
{
ptr = or_unpack_int (ptr, total_objects + i);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_unpack_int (ptr, failed_objects + i);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_unpack_int (ptr, modified_objects + i);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_unpack_int (ptr, big_objects + i);
}
for (i = 0; i < num_classes; i++)
{
ptr = or_unpack_int (ptr, ids_repr + i);
}
}
free_and_init (request);
free_and_init (reply);
return success;
#else /* CS_MODE */
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* boot_heap_compact () - compact heap file of gived class
*
* return : NO_ERROR if all OK, ER_ status otherwise
*
* class_oid(in): the class oid of heap to compact
*
* Note:
*/
int
boot_heap_compact (OID * class_oid)
{
#if defined(CS_MODE)
int success = ER_FAILED, request_size, req_error, reply_size;
OR_ALIGNED_BUF (OR_OID_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
if (class_oid == NULL)
{
return ER_QPROC_INVALID_PARAMETER;
}
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = OR_OID_SIZE;
reply_size = OR_INT_SIZE;
or_pack_oid (request, class_oid);
req_error =
net_client_request (NET_SERVER_BO_HEAP_COMPACT, request, request_size, reply, reply_size, NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &success);
}
return success;
#else /* CS_MODE */
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* compact_db_start () - start database compaction
*
* return : error code
*
*/
int
compact_db_start (void)
{
#if defined(CS_MODE)
int success = ER_FAILED, req_error, reply_size;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply_size = OR_INT_SIZE;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error = net_client_request (NET_SERVER_BO_COMPACT_DB_START, NULL, 0, reply, reply_size, NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &success);
}
return success;
#else /* CS_MODE */
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* compact_db_stop () - stop database compaction
*
* return :error code
*
*/
int
compact_db_stop (void)
{
#if defined(CS_MODE)
int success = ER_FAILED, req_error, reply_size;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
reply_size = OR_INT_SIZE;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error = net_client_request (NET_SERVER_BO_COMPACT_DB_STOP, NULL, 0, reply, reply_size, NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_int (reply, &success);
}
return success;
#else /* CS_MODE */
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* es_posix_create_file () - create an external file in a posix storage
*
* return :error code
*
*/
int
es_posix_create_file (char *new_path)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, path_size;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply, *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request2_no_malloc (NET_SERVER_ES_CREATE_FILE, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, new_path, &path_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &path_size);
ptr = or_unpack_int (ptr, &error);
}
return error;
#else /* CS_MODE */
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* es_posix_write_file () - write data in an esternal file
*
* return :error code
* path(in):
* buf(in):
* count(in):
* offset(in):
*/
ssize_t
es_posix_write_file (const char *path, const void *buf, size_t count, off_t offset)
{
#if defined(CS_MODE)
INT64 ret = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT64_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = DB_ALIGN (length_const_string (path, &strlen), MAX_ALIGNMENT) + OR_INT64_SIZE + OR_INT64_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, path, strlen);
ptr = or_pack_int64 (ptr, (INT64) offset);
ptr = or_pack_int64 (ptr, (INT64) count);
req_error = net_client_request (NET_SERVER_ES_WRITE_FILE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), (char *) buf, (int) count, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int64 (reply, &ret);
}
free_and_init (request);
return ret;
#else /* CS_MODE */
return ER_FAILED;
#endif /* !CS_MODE */
}
/*
* es_posix_read_file () - read data from an esternal file
*
* return :error code
* path(in):
* buf(out):
* count(in):
* offset(in):
*/
ssize_t
es_posix_read_file (const char *path, void *buf, size_t count, off_t offset)
{
#if defined(CS_MODE)
INT64 ret = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT64_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = DB_ALIGN (length_const_string (path, &strlen), MAX_ALIGNMENT) + OR_INT64_SIZE + OR_INT64_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, path, strlen);
ptr = or_pack_int64 (ptr, (INT64) offset);
ptr = or_pack_int64 (ptr, (INT64) count);
req_error =
net_client_request (NET_SERVER_ES_READ_FILE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, (char *) buf, (int) count);
if (!req_error)
{
ptr = or_unpack_int64 (reply, &ret);
}
free_and_init (request);
return ret;
#else /* CS_MODE */
return ER_FAILED;
#endif
}
/*
* es_posix_delete_file () - delete an external file
*
* return :error code
* path(in):
*/
int
es_posix_delete_file (const char *path)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (path, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, path, strlen);
req_error = net_client_request (NET_SERVER_ES_DELETE_FILE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &error);
}
free_and_init (request);
return error;
#else /* CS_MODE */
return ER_FAILED;
#endif
}
/*
* es_posix_copy_file () - copy an external file
*
* return :error code
* src_path(in):
* metaname(in):
* new_path(out):
*/
int
es_posix_copy_file (const char *src_path, const char *metaname, char *new_path)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, request_size, path_size, srclen, metalen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (src_path, &srclen) + length_const_string (metaname, &metalen);
request = (char *) malloc (request_size);
if (request == NULL)
{
error = ER_OUT_OF_VIRTUAL_MEMORY;
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, error, 1, (size_t) request_size);
return error;
}
ptr = pack_const_string_with_length (request, src_path, srclen);
ptr = pack_const_string_with_length (ptr, metaname, metalen);
req_error =
net_client_request2_no_malloc (NET_SERVER_ES_COPY_FILE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, new_path, &path_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &path_size);
ptr = or_unpack_int (ptr, &error);
}
free_and_init (request);
return error;
#else /* CS_MODE */
return ER_FAILED;
#endif
}
/*
* es_posix_rename_file () - rename an external file
*
* return :error code
* src_path(in):
* metaname(in):
* new_path(out):
*/
int
es_posix_rename_file (const char *src_path, const char *metaname, char *new_path)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, request_size, path_size, srclen, metalen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (src_path, &srclen) + length_const_string (metaname, &metalen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, src_path, srclen);
ptr = pack_const_string_with_length (ptr, metaname, metalen);
req_error =
net_client_request2_no_malloc (NET_SERVER_ES_RENAME_FILE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, new_path, &path_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &path_size);
ptr = or_unpack_int (ptr, &error);
}
free_and_init (request);
return error;
#else /* CS_MODE */
return ER_FAILED;
#endif
}
/*
* es_posix_get_file_size () - get the size of an esternal file
*
* return : file size or -1 on error
* path(in):
*/
off_t
es_posix_get_file_size (const char *path)
{
#if defined(CS_MODE)
INT64 tmp_int64;
off_t file_size = -1;
int req_error, request_size, strlen;
char *request, *reply;
OR_ALIGNED_BUF (OR_INT64_SIZE) a_reply;
char *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (path, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = pack_const_string_with_length (request, path, strlen);
req_error = net_client_request (NET_SERVER_ES_GET_FILE_SIZE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int64 (reply, &tmp_int64);
file_size = (off_t) tmp_int64;
}
free_and_init (request);
return file_size;
#else /* CS_MODE */
return -1;
#endif
}
/*
* cvacuum () - Client side function for vacuuming.
*
* return : Error code.
*/
int
cvacuum (void)
{
#if defined(CS_MODE)
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply = NULL;
int err = NO_ERROR;
/* Reply should include error code */
reply = OR_ALIGNED_BUF_START (a_reply);
/* Send request to server */
err = net_client_request (NET_SERVER_VACUUM, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (err == NO_ERROR)
{
(void) or_unpack_int (reply, &err);
}
return err;
#else /* !CS_MODE */
int err;
THREAD_ENTRY *thread_p = enter_server ();
/* Call server function for vacuuming */
err = xvacuum (thread_p);
exit_server (*thread_p);
return err;
#endif /* CS_MODE */
}
/*
* vacuum_dump -
*
* return:
*
* outfp(in):
*/
void
vacuum_dump (FILE * outfp)
{
#if defined(CS_MODE)
int req_error;
if (outfp == NULL)
{
outfp = stdout;
}
req_error = net_client_request_recv_stream (NET_SERVER_VACUUM_DUMP, NULL, 0, NULL, 0, NULL, 0, outfp);
#else /* CS_MODE */
THREAD_ENTRY *thread_p = enter_server ();
xvacuum_dump (thread_p, outfp);
exit_server (*thread_p);
#endif /* !CS_MODE */
}
/*
* log_get_mvcc_snapshot () - Get MVCC snapshot on server.
*
* return : Error code.
*/
int
log_get_mvcc_snapshot (void)
{
#if defined(CS_MODE)
char *reply;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
int err = NO_ERROR;
reply = OR_ALIGNED_BUF_START (a_reply);
err =
net_client_request (NET_SERVER_GET_MVCC_SNAPSHOT, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (err != NO_ERROR)
{
or_unpack_int (reply, &err);
}
return err;
#else /* !CS_MODE */
int err;
THREAD_ENTRY *thread_p = enter_server ();
err = xlogtb_get_mvcc_snapshot (thread_p);
exit_server (*thread_p);
return err;
#endif /* CS_MODE */
}
/*
* locator_upgrade_instances_domain () - performs an upgrade of domain for
* instances of a class
* return : NO_ERROR if all OK, error status otherwise
* class_oid(in) : class whose instances must be upgraded
* attribute_id(in) : id attribute which must be upgraded
*
* Note: Used on ALTER CHANGE (with type change syntax) context
*/
int
locator_upgrade_instances_domain (OID * class_oid, int attribute_id)
{
#if defined(CS_MODE)
int success = ER_FAILED, req_error;
OR_ALIGNED_BUF (OR_OID_SIZE + OR_INT_SIZE) a_request;
char *request, *reply, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
if (class_oid == NULL || OID_ISNULL (class_oid) || attribute_id < 0)
{
return ER_QPROC_INVALID_PARAMETER;
}
ptr = request;
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, attribute_id);
req_error =
net_client_request (NET_SERVER_LC_UPGRADE_INSTANCES_DOMAIN, request,
OR_ALIGNED_BUF_SIZE (a_request), reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
}
return success;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
error = xlocator_upgrade_instances_domain (thread_p, class_oid, attribute_id);
exit_server (*thread_p);
return error;
#endif /* !CS_MODE */
}
/*
* boot_get_server_locales () - get information about server locales
*
* return : error code or no error
*/
int
boot_get_server_locales (LANG_COLL_COMPAT ** server_collations, LANG_LOCALE_COMPAT ** server_locales,
int *server_coll_cnt, int *server_locales_cnt)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply = NULL;
char *reply_data = NULL;
char *ptr = NULL;
int reply_size = 0, temp_int, i, dummy;
char *temp_str;
size_t size;
assert (server_collations != NULL);
assert (server_locales != NULL);
assert (server_coll_cnt != NULL);
assert (server_locales_cnt != NULL);
*server_collations = NULL;
*server_locales = NULL;
*server_coll_cnt = 0;
*server_locales_cnt = 0;
req_error =
net_client_request2 (NET_SERVER_BO_GET_LOCALES_INFO, NULL, 0, OR_ALIGNED_BUF_START (a_reply),
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &reply_data, &reply_size);
if (req_error != NO_ERROR)
{
goto error;
}
reply = OR_ALIGNED_BUF_START (a_reply);
/* unpack data size */
ptr = or_unpack_int (reply, &dummy);
/* unpack error code */
ptr = or_unpack_int (ptr, &req_error);
if (req_error != NO_ERROR)
{
goto error;
}
assert (req_error == NO_ERROR);
assert (reply_data != NULL);
ptr = or_unpack_int (reply_data, server_coll_cnt);
ptr = or_unpack_int (ptr, server_locales_cnt);
size = (*server_coll_cnt * sizeof (LANG_COLL_COMPAT));
*server_collations = (LANG_COLL_COMPAT *) malloc (size);
if (*server_collations == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) size);
req_error = ER_FAILED;
goto error;
}
size = (*server_locales_cnt * sizeof (LANG_LOCALE_COMPAT));
*server_locales = (LANG_LOCALE_COMPAT *) malloc (size);
if (*server_locales == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) size);
req_error = ER_FAILED;
goto error;
}
for (i = 0; i < *server_coll_cnt; i++)
{
LANG_COLL_COMPAT *ref_coll = &((*server_collations)[i]);
ptr = or_unpack_int (ptr, &(ref_coll->coll_id));
ptr = or_unpack_string_nocopy (ptr, &(temp_str));
strncpy (ref_coll->coll_name, temp_str, sizeof (ref_coll->coll_name) - 1);
ref_coll->coll_name[sizeof (ref_coll->coll_name) - 1] = '\0';
ptr = or_unpack_int (ptr, &(temp_int));
ref_coll->codeset = (INTL_CODESET) temp_int;
ptr = or_unpack_string_nocopy (ptr, &(temp_str));
strncpy (ref_coll->checksum, temp_str, sizeof (ref_coll->checksum) - 1);
ref_coll->checksum[sizeof (ref_coll->checksum) - 1] = '\0';
}
for (i = 0; i < *server_locales_cnt; i++)
{
LANG_LOCALE_COMPAT *ref_loc = &((*server_locales)[i]);
ptr = or_unpack_string_nocopy (ptr, &(temp_str));
strncpy (ref_loc->lang_name, temp_str, sizeof (ref_loc->lang_name) - 1);
ref_loc->lang_name[sizeof (ref_loc->lang_name) - 1] = '\0';
ptr = or_unpack_int (ptr, &(temp_int));
ref_loc->codeset = (INTL_CODESET) temp_int;
ptr = or_unpack_string_nocopy (ptr, &(temp_str));
strncpy (ref_loc->checksum, temp_str, sizeof (ref_loc->checksum) - 1);
ref_loc->checksum[sizeof (ref_loc->checksum) - 1] = '\0';
}
if (reply_data != NULL)
{
free_and_init (reply_data);
}
return req_error;
error:
if (reply_data != NULL)
{
free_and_init (reply_data);
}
return req_error;
#else
return -1;
#endif
}
/*
* tran_lock_rep_read () - Lock the object that is common to all RR transactions
* return : NO_ERROR if all OK, error status otherwise
* lock_rr_tran(in) : type of lock
*
* Note: This is used in ALTER TABLE ... ADD COLUMN ... NOT NULL scenarios
*/
int
tran_lock_rep_read (LOCK lock_rr_tran)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request, *reply, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = request;
ptr = or_pack_int (ptr, (int) lock_rr_tran);
req_error =
net_client_request (NET_SERVER_LOCK_RR, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &req_error);
}
if (req_error == NO_ERROR)
{
tm_Tran_rep_read_lock = lock_rr_tran;
}
return req_error;
#else /* CS_MODE */
return NO_ERROR; /* No need to lock */
#endif /* !CS_MODE */
}
/*
* boot_get_server_timezone_checksum () - get the timezone checksum from the
* server
*
* return : error code or no error
*/
int
boot_get_server_timezone_checksum (char *timezone_checksum)
{
#if defined(CS_MODE)
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply = NULL;
char *reply_data = NULL;
char *ptr = NULL;
int reply_size = 0, dummy;
char *temp_str;
req_error =
net_client_request2 (NET_SERVER_TZ_GET_CHECKSUM, NULL, 0, OR_ALIGNED_BUF_START (a_reply),
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &reply_data, &reply_size);
if (req_error != NO_ERROR)
{
goto error;
}
reply = OR_ALIGNED_BUF_START (a_reply);
/* unpack data size */
ptr = or_unpack_int (reply, &dummy);
/* unpack error code */
ptr = or_unpack_int (ptr, &req_error);
if (req_error != NO_ERROR)
{
goto error;
}
assert (reply_data != NULL);
ptr = or_unpack_string_nocopy (reply_data, &(temp_str));
strncpy (timezone_checksum, temp_str, TZ_CHECKSUM_SIZE);
timezone_checksum[TZ_CHECKSUM_SIZE] = '\0';
if (reply_data != NULL)
{
free_and_init (reply_data);
}
return req_error;
error:
if (reply_data != NULL)
{
free_and_init (reply_data);
}
return req_error;
#else
return -1;
#endif
}
int
chksum_insert_repl_log_and_demote_table_lock (REPL_INFO * repl_info, const OID * class_oidp)
{
#if defined(CS_MODE)
int req_error, success = ER_FAILED;
int request_size = 0, strlen1, strlen2, strlen3, strlen4;
char *request = NULL, *ptr;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
REPL_INFO_SBR *repl_stmt;
reply = OR_ALIGNED_BUF_START (a_reply);
switch (repl_info->repl_info_type)
{
case REPL_INFO_TYPE_SBR:
repl_stmt = (REPL_INFO_SBR *) repl_info->info;
request_size = (OR_OID_SIZE /* class oid */
+ OR_INT_SIZE /* REPL_INFO.REPL_INFO_TYPE */
+ OR_INT_SIZE /* REPL_INFO_SCHEMA.statement_type */
+ length_const_string (repl_stmt->name, &strlen1)
+ length_const_string (repl_stmt->stmt_text, &strlen2)
+ length_const_string (repl_stmt->db_user, &strlen3)
+ length_const_string (repl_stmt->sys_prm_context, &strlen4));
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_FAILED;
}
ptr = or_pack_oid (request, class_oidp);
ptr = or_pack_int (ptr, REPL_INFO_TYPE_SBR);
ptr = or_pack_int (ptr, repl_stmt->statement_type);
ptr = pack_const_string_with_length (ptr, repl_stmt->name, strlen1);
ptr = pack_const_string_with_length (ptr, repl_stmt->stmt_text, strlen2);
ptr = pack_const_string_with_length (ptr, repl_stmt->db_user, strlen3);
ptr = pack_const_string_with_length (ptr, repl_stmt->sys_prm_context, strlen4);
req_error =
net_client_request (NET_SERVER_CHKSUM_REPL, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &success);
}
free_and_init (request);
break;
default:
break;
}
return success;
#else /* CS_MODE */
int r = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
r = xchksum_insert_repl_log_and_demote_table_lock (thread_p, repl_info, class_oidp);
exit_server (*thread_p);
return r;
#endif /* !CS_MODE */
}
/*
* log_does_active_user_exist () - Cbeck the specified user is an
* active user or not
* return: error code
* user_name(in) :
* existed (out) : true mean user is an active user
*/
int
log_does_active_user_exist (const char *user_name, bool * existed)
{
#if defined(CS_MODE)
int error;
int xexisted;
int req_error, request_size, strlen;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
*existed = false;
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = length_const_string (user_name, &strlen);
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
(void) pack_const_string_with_length (request, user_name, strlen);
req_error = net_client_request (NET_SERVER_AU_DOES_ACTIVE_USER_EXIST, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &xexisted);
if ((bool) xexisted)
{
*existed = true;
}
error = NO_ERROR;
}
else
{
assert (er_errid () != NO_ERROR);
error = er_errid ();
}
free_and_init (request);
return error;
#else /* CS_MODE */
/* in SA_MODE, no other active user */
*existed = false;
return NO_ERROR;
#endif /* !CS_MODE */
}
/*
* locator_redistribute_partition_data () - redistribute partition data
*
* return : error code
*
* thread_p (in) :
* class_oid (in) : parent class OID
* no_oids (in) : number of OIDs in the list (promoted partitions)
* oid_list (in) : partition OID list (promoted partitions)
*/
int
locator_redistribute_partition_data (OID * class_oid, int no_oids, OID * oid_list)
{
#if defined(CS_MODE)
int success = ER_FAILED, req_error;
char *request, *reply, *ptr;
int request_size = 0;
int i;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
reply = OR_ALIGNED_BUF_START (a_reply);
if (oid_list == NULL || no_oids < 1)
{
return ER_QPROC_INVALID_PARAMETER;
}
request_size = OR_OID_SIZE + OR_INT_SIZE + no_oids * OR_OID_SIZE;
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = request;
ptr = or_pack_oid (ptr, class_oid);
ptr = or_pack_int (ptr, no_oids);
for (i = 0; i < no_oids; i++)
{
ptr = or_pack_oid (ptr, &oid_list[i]);
}
req_error =
net_client_request (NET_SERVER_LC_REDISTRIBUTE_PARTITION_DATA, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &success);
}
free_and_init (request);
return success;
#else /* CS_MODE */
int success = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
success = xlocator_redistribute_partition_data (thread_p, class_oid, no_oids, oid_list);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* netcl_spacedb () - client-side function to get database space info
*
* return : error code
* spaceall (out) : output aggregated space information
* spacevols (out) : if not NULL, output space information per volume
* spacefiles (out) : if not NULL, out detailed space information on file usage
*/
int
netcl_spacedb (SPACEDB_ALL * spaceall, SPACEDB_ONEVOL ** spacevols, SPACEDB_FILES * spacefiles)
{
#if defined (CS_MODE)
int error_code = NO_ERROR;
OR_ALIGNED_BUF (2 * OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (2 * OR_INT_SIZE) a_reply;
char *reply;
char *data_reply = NULL;
int data_reply_size = 0;
char *ptr;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_int (request, spacevols != NULL ? 1 : 0);
ptr = or_pack_int (ptr, spacefiles != NULL ? 1 : 0);
error_code = net_client_request2 (NET_SERVER_SPACEDB, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &data_reply, &data_reply_size);
if (error_code != NO_ERROR)
{
assert (data_reply == NULL);
return error_code;
}
ptr = or_unpack_int (reply, &data_reply_size);
ptr = or_unpack_int (ptr, &error_code);
if (error_code != NO_ERROR)
{
/* error */
ASSERT_ERROR ();
return error_code;
}
if (data_reply == NULL)
{
assert_release (false);
return ER_FAILED;
}
ptr = or_unpack_spacedb (data_reply, spaceall, spacevols, spacefiles);
if (ptr == NULL)
{
ASSERT_ERROR_AND_SET (error_code);
return error_code;
}
assert ((ptr - data_reply) == data_reply_size);
free_and_init (data_reply);
return NO_ERROR;
#else /* !CS_MODE */ /* SA_MDOE */
int error_code = ER_FAILED;
THREAD_ENTRY *thread_p = enter_server ();
error_code = disk_spacedb (thread_p, spaceall, spacevols);
if (error_code != NO_ERROR)
{
ASSERT_ERROR ();
}
else if (spacefiles != NULL)
{
error_code = file_spacedb (thread_p, spacefiles);
if (error_code != NO_ERROR)
{
ASSERT_ERROR ();
}
}
exit_server (*thread_p);
return error_code;
#endif /* SA_MODE */
}
int
locator_demote_class_lock (const OID * class_oid, LOCK lock, LOCK * ex_lock)
{
#if defined(CS_MODE)
int rc = ER_FAILED;
int req_error;
char *ptr;
OR_ALIGNED_BUF (OR_OID_SIZE + OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_oid (request, class_oid);
ptr = or_pack_lock (ptr, lock);
req_error =
net_client_request (NET_SERVER_LC_DEMOTE_CLASS_LOCK, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_int (reply, &rc);
ptr = or_unpack_lock (ptr, ex_lock);
}
if (rc == NO_ERROR)
{
// demote cached lock
MOP class_mop = ws_mop (class_oid, sm_Root_class_mop);
if (class_mop != NULL)
{
ws_set_lock (class_mop, lock);
}
}
return rc;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
loaddb_init (cubload::load_args & args)
{
#if defined(CS_MODE)
int rc = ER_FAILED;
packing_packer packer;
cubmem::extensible_block eb;
packer.set_buffer_and_pack_all (eb, args);
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
int req_error = net_client_request (NET_SERVER_LD_INIT, eb.get_ptr (), (int) packer.get_current_size (), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &rc);
}
return rc;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
loaddb_install_class (const cubload::batch & batch, bool & class_is_ignored, std::string & class_name)
{
#if defined(CS_MODE)
int rc = ER_FAILED;
packing_packer packer;
cubmem::extensible_block eb;
int class_ignored = 0;
char *ptr = NULL;
packer.set_buffer_and_pack_all (eb, batch);
OR_ALIGNED_BUF (3 * OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
char *area = NULL;
int area_size;
int req_error = net_client_request2 (NET_SERVER_LD_INSTALL_CLASS, eb.get_ptr (), (int) packer.get_current_size (),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (!req_error)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &rc);
ptr = or_unpack_int (ptr, &class_ignored);
assert (area_size < DB_MAX_IDENTIFIER_LENGTH);
class_name = std::string (area, area_size);
free_and_init (area);
class_is_ignored = class_ignored != 0;
}
return rc;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
loaddb_load_batch (const cubload::batch & batch, bool use_temp_batch, bool & is_batch_accepted, load_status & status)
{
#if defined(CS_MODE)
char *data_reply = NULL;
int data_reply_size = 0;
OR_ALIGNED_BUF (OR_INT_SIZE * 3) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
packing_packer packer;
cubmem::extensible_block eb;
if (use_temp_batch)
{
packer.set_buffer_and_pack_all (eb, use_temp_batch);
}
else
{
packer.set_buffer_and_pack_all (eb, use_temp_batch, batch);
}
int req_error = net_client_request2 (NET_SERVER_LD_LOAD_BATCH, eb.get_ptr (), (int) packer.get_current_size (),
reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &data_reply, &data_reply_size);
if (req_error != NO_ERROR)
{
return req_error;
}
char *ptr = or_unpack_int (reply, &data_reply_size);
int rc = ER_FAILED;
ptr = or_unpack_int (ptr, &rc);
if (rc != NO_ERROR)
{
free_and_init (data_reply);
return rc;
}
int is_batch_accepted_;
or_unpack_int (ptr, &is_batch_accepted_);
is_batch_accepted = is_batch_accepted_ != 0;
packing_unpacker unpacker (data_reply, (size_t) data_reply_size);
status.unpack (unpacker);
free_and_init (data_reply);
return rc;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
loaddb_fetch_status (load_status & status)
{
#if defined(CS_MODE)
char *data_reply = NULL;
int data_reply_size = 0;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
int req_error = net_client_request2 (NET_SERVER_LD_FETCH_STATUS, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply),
NULL,
0, &data_reply, &data_reply_size);
if (req_error != NO_ERROR)
{
return req_error;
}
or_unpack_int (reply, &data_reply_size);
if (data_reply_size <= 0)
{
return ER_FAILED;
}
packing_unpacker unpacker (data_reply, (size_t) data_reply_size);
status.unpack (unpacker);
free_and_init (data_reply);
return req_error;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
loaddb_destroy ()
{
#if defined(CS_MODE)
int rc = ER_FAILED;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
int req_error = net_client_request (NET_SERVER_LD_DESTROY, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0,
NULL, 0);
if (!req_error)
{
or_unpack_int (reply, &rc);
}
return rc;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
loaddb_interrupt ()
{
#if defined(CS_MODE)
return net_client_request_no_reply (NET_SERVER_LD_INTERRUPT, NULL, 0);
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
loaddb_update_stats (bool verbose)
{
#if defined(CS_MODE)
int rc = ER_FAILED;
char *data_reply = NULL;
int data_reply_size = 0;
OR_ALIGNED_BUF (OR_INT_SIZE * 2) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
OID oid;
int oids_count;
MOP classop;
/* get class oid */
int req_error = net_client_request2 (NET_SERVER_LD_UPDATE_STATS, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &data_reply,
&data_reply_size);
if (req_error != NO_ERROR)
{
return req_error;
}
char *ptr = or_unpack_int (reply, &data_reply_size);
ptr = or_unpack_int (ptr, &rc);
if (rc != NO_ERROR || data_reply_size == 0)
{
rc = ER_FAILED;
goto cleanup;
}
/* unpack number of returned OIDs */
ptr = or_unpack_int (data_reply, &oids_count);
for (int i = 0; i < oids_count; i++)
{
ptr = or_unpack_oid (ptr, &oid);
classop = ws_mop (&oid, NULL);
assert (classop != NULL);
if (classop != NULL)
{
if (verbose)
{
const char *class_name_p = db_get_class_name (classop);
if (class_name_p != NULL)
{
fprintf (stdout,
msgcat_message (MSGCAT_CATALOG_UTILS, MSGCAT_UTIL_SET_LOADDB, LOADDB_MSG_CLASS_TITLE),
class_name_p);
fflush (stdout);
}
}
stats_update_statistics (classop, STATS_WITH_SAMPLING);
}
}
cleanup:
if (data_reply != NULL)
{
free_and_init (data_reply);
}
return rc;
#else /* CS_MODE */
return NO_ERROR;
#endif /* !CS_MODE */
}
int
pl_call (const cubpl::pl_signature & sig, const std::vector < std::reference_wrapper < DB_VALUE >> &args,
std::vector < DB_VALUE > &out_args, DB_VALUE & result)
{
int req_error = NO_ERROR;
#if defined(CS_MODE)
char *data_reply = NULL;
int data_reply_size = 0;
packing_packer packer;
cubmem::extensible_block eb;
packer.set_buffer_and_pack_all (eb, sig, args);
{
OR_ALIGNED_BUF (OR_INT_SIZE * 3) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
req_error = net_client_request_method_callback (NET_SERVER_PL_CALL, eb.get_ptr (),
(int) packer.get_current_size (), reply,
OR_ALIGNED_BUF_SIZE (a_reply), &data_reply, &data_reply_size);
if (req_error != NO_ERROR)
{
goto error;
}
/* consumes dummy reply */
int dummy;
char *ptr = or_unpack_int (reply, &dummy);
ptr = or_unpack_int (ptr, &dummy);
ptr = or_unpack_int (ptr, &dummy);
/* receive result values / error */
if (data_reply != NULL)
{
packing_unpacker unpacker (data_reply, (size_t) data_reply_size);
if (data_reply_size > 0)
{
unpacker.unpack_all (result, out_args);
}
}
else
{
db_make_null (&result);
}
}
error:
if (req_error != NO_ERROR)
{
packing_unpacker unpacker (data_reply, (size_t) data_reply_size);
int error_code;
std::string error_msg;
if (data_reply_size > 0)
{
unpacker.unpack_all (error_code, error_msg);
cubmethod::handle_method_error (error_code, error_msg);
req_error = error_code;
}
}
if (data_reply != NULL)
{
free_and_init (data_reply);
}
return req_error;
#else
packing_packer packer;
cubmem::extensible_block eb;
THREAD_ENTRY *thread_p = enter_server ();
{
DB_VALUE ret_value;
cubpl::executor executor ((cubpl::pl_signature &) sig);
req_error = executor.fetch_args_peek (args);
if (req_error == NO_ERROR)
{
req_error = executor.execute (ret_value);
}
if (req_error == NO_ERROR)
{
/* 3) pack */
packer.set_buffer_and_pack_all (eb, ret_value, executor.get_out_args ());
}
else
{
std::string err_msg;
if (executor.get_stack ())
{
err_msg = executor.get_stack ()->get_error_message ();
}
if (err_msg.empty () && req_error != ER_SP_EXECUTE_ERROR)
{
err_msg.assign (er_msg ());
}
if (req_error != ER_SM_INVALID_METHOD_ENV) /* FIXME: error possibly occured in builtin method, It should be handled at CAS */
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_SP_EXECUTE_ERROR, 1, err_msg.c_str ());
req_error = ER_SP_EXECUTE_ERROR;
}
packer.set_buffer_and_pack_all (eb, er_errid (), err_msg);
}
db_value_clear (&ret_value);
}
exit_server (*thread_p);
// unpack after exit_server (): ownership of the private allocated objects should be out of server mode
packing_unpacker unpacker (eb.get_ptr (), (size_t) packer.get_current_size ());
if (req_error == NO_ERROR)
{
db_make_null (&result);
unpacker.unpack_all (result, out_args);
}
else
{
int error_code;
std::string error_msg;
unpacker.unpack_all (error_code, error_msg);
cubmethod::handle_method_error (error_code, error_msg);
}
return req_error;
#endif
}
/*
* flashabck_get_and_show_summary () - client-side function to get and show flashback summary
*
* return : error code
* class_list (in) : class name list to flashback
* user (in) : transaction user to flashback
* start_time (in) : flashback sql logs are extracted from 'start_time'
* end_time (in) : flashback sql logs are extracted until 'end_time'
* summary (out) : summary information retrieved from server
* oid_list (out) : class oid list that is extracted with 'class_list'
*/
int
flashback_get_and_show_summary (dynamic_array * class_list, const char *user, time_t start_time, time_t end_time,
FLASHBACK_SUMMARY_INFO_MAP * summary, OID ** oid_list, char **invalid_class,
time_t * invalid_time)
{
#if defined(CS_MODE)
int error_code = ER_FAILED;
int request_size = 0;
char *request = NULL, *ptr, *start_ptr;
int num_class = 0;
int num_summary = 0;
char classname[SM_MAX_IDENTIFIER_LENGTH];
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
char *area;
int area_size;
num_class = da_size (class_list);
/* request : num class | class name list | user | start_time | end_time */
request_size = OR_INT_SIZE + or_packed_string_length (user, NULL) + OR_INT64_SIZE + OR_INT64_SIZE;
for (int i = 0; i < num_class; i++)
{
if (da_get (class_list, i, classname) != NO_ERROR)
{
/* TODO : er_set() */
return ER_FAILED;
}
request_size += or_packed_string_length (classname, NULL);
}
request = (char *) malloc (request_size + MAX_ALIGNMENT);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = start_ptr = PTR_ALIGN (request, MAX_ALIGNMENT);
ptr = or_pack_int (ptr, num_class);
for (int i = 0; i < num_class; i++)
{
if (da_get (class_list, i, classname) != NO_ERROR)
{
free_and_init (request);
return ER_FAILED;
}
ptr = or_pack_string (ptr, classname);
}
ptr = or_pack_string (ptr, user);
ptr = or_pack_int64 (ptr, start_time);
ptr = or_pack_int64 (ptr, end_time);
request_size = ptr - start_ptr;
error_code =
net_client_request2 (NET_SERVER_FLASHBACK_GET_SUMMARY, start_ptr, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (error_code == NO_ERROR)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error_code);
if (error_code == ER_FLASHBACK_INVALID_CLASS)
{
*invalid_class = (char *) calloc (area_size + 1, sizeof (char));
if (*invalid_class == NULL)
{
error_code = ER_OUT_OF_VIRTUAL_MEMORY;
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, area_size);
}
memcpy (*invalid_class, area, area_size);
}
else if (error_code == ER_FLASHBACK_INVALID_TIME)
{
or_unpack_int64 (area, invalid_time);
}
else if (error_code == NO_ERROR)
{
ptr = area;
/* area : OID list | summary info list */
for (int i = 0; i < num_class; i++)
{
ptr = or_unpack_oid (ptr, &(*oid_list)[i]);
}
/* get summary info */
error_code = flashback_unpack_and_print_summary (&ptr, summary, class_list, *oid_list);
}
free_and_init (area);
}
free_and_init (request);
return error_code;
#endif // CS_MODE
return ER_NOT_IN_STANDALONE;
}
/*
* flashback_get_loginfo () - client-side function to get flashback log info
*
* return : error code
* trid (in) : specifies transactions to flashback
* user (in) : specifies transaction user
* classlist (in) : specifies classes to flashback
* num_class (in) : number of class in classlist
* start_lsa (in/out) : start lsa to extract log record
* end_lsa (in/out) : end lsa to extract log record
* num_info (in/out) : number of log info to extract, and number of log info that is extracted
* forward (in) : direction of traversing log records
* info_list (out) : log info list
*/
int
flashback_get_loginfo (int trid, char *user, OID * classlist, int num_class, LOG_LSA * start_lsa, LOG_LSA * end_lsa,
int *num_item, bool forward, char **info_list, int *invalid_class_idx)
{
#if defined(CS_MODE)
int error_code = ER_FAILED;
int request_size = 0;
char *request = NULL, *ptr, *start_ptr;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
char *area;
int area_size;
/* request with : tranid, user, num class, classlist, start_lsa, end_lsa, num_item, forward/backward */
request_size =
OR_INT_SIZE + or_packed_string_length (user,
NULL) + OR_INT_SIZE + OR_OID_SIZE * num_class + OR_LOG_LSA_ALIGNED_SIZE * 2 +
OR_INT_SIZE + OR_INT_SIZE;
request = (char *) malloc (request_size + MAX_ALIGNMENT);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
ptr = start_ptr = PTR_ALIGN (request, MAX_ALIGNMENT);
ptr = or_pack_int (ptr, trid);
ptr = or_pack_string (ptr, user);
ptr = or_pack_int (ptr, num_class);
for (int i = 0; i < num_class; i++)
{
ptr = or_pack_oid (ptr, &classlist[i]);
}
ptr = or_pack_log_lsa (ptr, start_lsa);
ptr = or_pack_log_lsa (ptr, end_lsa);
ptr = or_pack_int (ptr, *num_item);
ptr = or_pack_int (ptr, (int) forward);
request_size = ptr - start_ptr;
error_code =
net_client_request2 (NET_SERVER_FLASHBACK_GET_LOGINFO, start_ptr, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &area, &area_size);
if (error_code == NO_ERROR)
{
ptr = or_unpack_int (reply, &area_size);
ptr = or_unpack_int (ptr, &error_code);
if (error_code == ER_FLASHBACK_SCHEMA_CHANGED)
{
OID invalid_classoid;
or_unpack_oid (area, &invalid_classoid);
*invalid_class_idx = flashback_find_class_index (classlist, num_class, invalid_classoid);
}
else if (error_code == NO_ERROR)
{
/* area : start lsa | end lsa | num item | item list */
ptr = or_unpack_log_lsa (area, start_lsa);
ptr = or_unpack_log_lsa (ptr, end_lsa);
ptr = or_unpack_int (ptr, num_item);
ptr = PTR_ALIGN (ptr, MAX_ALIGNMENT);
*info_list = (char *) malloc (area_size - (ptr - area));
if (*info_list == NULL)
{
error_code = ER_OUT_OF_VIRTUAL_MEMORY;
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, area_size - (ptr - area));
}
memcpy (*info_list, ptr, area_size - (ptr - area));
}
free_and_init (area);
}
free_and_init (request);
return error_code;
#endif // CS_MODE
return ER_NOT_IN_STANDALONE;
}
int
plcsql_transfer_file (const PLCSQL_COMPILE_REQUEST & compile_request, PLCSQL_COMPILE_RESPONSE & compile_response)
{
int req_error = NO_ERROR;
#if defined(CS_MODE)
packing_packer packer;
cubmem::extensible_block eb;
char *ptr = NULL;
char *data_reply = NULL;
int data_reply_size = 0;
packer.set_buffer_and_pack_all (eb, compile_request);
OR_ALIGNED_BUF (3 * OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
req_error = net_client_request_method_callback (NET_SERVER_PLCSQL_TRANSFER_FILE, eb.get_ptr (),
(int) packer.get_current_size (),
reply, OR_ALIGNED_BUF_SIZE (a_reply), &data_reply, &data_reply_size);
if (req_error != NO_ERROR)
{
goto error;
}
/* consumes dummy reply */
int dummy;
ptr = or_unpack_int (reply, &dummy);
ptr = or_unpack_int (ptr, &dummy);
ptr = or_unpack_int (ptr, &dummy);
/* receive result values / error */
if (data_reply != NULL)
{
packing_unpacker unpacker (data_reply, (size_t) data_reply_size);
if (data_reply_size > 0)
{
unpacker.unpack_all (compile_response);
}
}
error:
if (req_error != NO_ERROR)
{
if (data_reply != NULL)
{
packing_unpacker unpacker (data_reply, (size_t) data_reply_size);
if (data_reply_size > 0)
{
unpacker.unpack_all (compile_response);
}
}
if (compile_response.err_code == NO_ERROR)
{
compile_response.err_code = (er_errid () != NO_ERROR) ? er_errid () : req_error;
compile_response.err_msg = er_msg ()? er_msg () : "unknown compile error";
}
}
if (data_reply != NULL)
{
free_and_init (data_reply);
}
return req_error;
#else /* CS_MODE */
int success = ER_FAILED;
cubmem::extensible_block eb;
THREAD_ENTRY *thread_p = enter_server ();
{
cubpl::compile_handler compile_handler;
success = compile_handler.compile (compile_request, eb);
}
exit_server (*thread_p);
// unpack after exit_server (): ownership of the private allocated objects should be out of server mode
if (success == NO_ERROR)
{
packing_unpacker unpacker (eb.get_ptr (), eb.get_size ());
if (eb.get_size () > 0)
{
unpacker.unpack_all (compile_response);
}
}
else
{
compile_response.err_code = (er_errid () != NO_ERROR) ? er_errid () : success;
compile_response.err_msg = er_msg ()? er_msg () : "unknown compile error";
}
return success;
#endif /* !CS_MODE */
}
/*
* mmon_get_server_info - request to server to get server memory usage info
*
* return : cubrid error
*
* server_info(in/out): save memory usage information of the server
*/
int
mmon_get_server_info (MMON_SERVER_INFO & server_info)
{
#if defined(CS_MODE)
char *buffer, *ptr, *temp_str;
int bufsize = 0;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
int req_error, dummy;
int error = NO_ERROR;
req_error =
net_client_request2 (NET_SERVER_MMON_GET_SERVER_INFO, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &buffer, &bufsize);
if (req_error)
{
assert (er_errid () != NO_ERROR);
error = er_errid ();
}
else
{
ptr = reply;
ptr = or_unpack_int (ptr, &dummy);
ptr = or_unpack_int (ptr, &error);
}
if (error == NO_ERROR)
{
// unpack server name
ptr = or_unpack_string_nocopy (buffer, &temp_str);
memcpy (server_info.server_name, temp_str, strlen (temp_str) + 1);
// unpack server total memory usage
ptr = or_unpack_int64 (ptr, (int64_t *) & (server_info.total_mem_usage));
// unpack metainfo total memory usage
ptr = or_unpack_int64 (ptr, (int64_t *) & (server_info.total_metainfo_mem_usage));
// unpack the number of stat
ptr = or_unpack_int (ptr, (int *) &(server_info.num_stat));
// unpack file name and its memory usage
server_info.stat_info.resize (server_info.num_stat);
// *INDENT-OFF*
// unpack memory usage entry info
for (auto &s_info : server_info.stat_info)
{
ptr = or_unpack_string_nocopy (ptr, &temp_str);
s_info.first = temp_str;
ptr = or_unpack_int64 (ptr, (int64_t *) &(s_info.second));
}
// *INDENT-ON*
}
free_and_init (buffer);
return error;
#else /* CS_MODE */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_NOT_IN_STANDALONE, 1, "memmon");
return ER_NOT_IN_STANDALONE;
#endif /* !CS_MODE */
}
/*
* mmon_disable_force - request to server to disable memory_monitor forcely
*
* return : cubrid error
*/
int
mmon_disable_force ()
{
#if defined(CS_MODE)
char *buffer, *ptr;
int bufsize = 0;
OR_ALIGNED_BUF (OR_INT_SIZE + OR_INT_SIZE) a_reply;
char *reply = OR_ALIGNED_BUF_START (a_reply);
int req_error, dummy;
int error = NO_ERROR;
req_error =
net_client_request2 (NET_SERVER_MMON_DISABLE_FORCE, NULL, 0, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, &buffer, &bufsize);
if (req_error)
{
assert (er_errid () != NO_ERROR);
error = er_errid ();
}
else
{
ptr = reply;
ptr = or_unpack_int (ptr, &dummy);
ptr = or_unpack_int (ptr, &error);
}
free_and_init (buffer);
return error;
#else /* CS_MODE */
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_NOT_IN_STANDALONE, 1, "memmon");
return ER_NOT_IN_STANDALONE;
#endif /* !CS_MODE */
}
/*
* tdes_set_query_start_info () - set the start time and sql text of the transaction
* return: none
* sql_user_text(in): the sql user text
*/
void
tdes_set_query_start_info (char *sql_user_text)
{
#if defined(CS_MODE)
char *request, *ptr;
int request_len;
request_len = or_packed_string_length (sql_user_text, NULL);
assert (request_len > 0);
request = (char *) malloc (request_len);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_len);
return;
}
ptr = or_pack_string (request, sql_user_text);
assert (ptr <= request + request_len);
net_client_request (NET_SERVER_TDES_SET_QUERY_START_INFO, request, request_len, NULL, 0, NULL, 0, NULL, 0);
free_and_init (request);
#endif /* !CS_MODE */
}
/*
* tdes_reset_query_start_info () - reset the query start time if the statement is a DDL statement
* return: none
* node(in): node to check if the statement is DDL
*/
void
tdes_reset_query_start_info (PT_NODE * node)
{
#if defined(CS_MODE)
if (pt_is_ddl_statement (node))
{
net_client_request (NET_SERVER_TDES_RESET_QUERY_START_INFO, NULL, 0, NULL, 0, NULL, 0, NULL, 0);
}
#endif
}
/* lob_create_dir - create external lob directory
*
* return: error code
*
* hfid(in): When creating the LOB directory, use each table's HFID as the directory name to distinguish them
* attrid_arr (in): An array that stores LOB attribute ids of the table.
* When creating the LOB directory, each LOB attribute is distinguished by its id
* lob_attrid_arr_length(in): length of attrid_arr
*/
int
lob_create_dir (HFID * hfid, int *attrid_arr, int lob_attrid_arr_length)
{
#if defined(CS_MODE)
char *ptr = NULL;
char *reply = NULL;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *request = NULL;
char request_local[OR_HFID_SIZE + OR_INT_SIZE + (OR_INT_SIZE * 2)];
int req_error, request_size;
int error = ER_NET_CLIENT_DATA_RECEIVE;
assert (!HFID_IS_NULL (hfid) && hfid != NULL);
reply = OR_ALIGNED_BUF_START (a_reply);
request_size = OR_HFID_SIZE + OR_INT_SIZE + (OR_INT_SIZE * lob_attrid_arr_length);
if (lob_attrid_arr_length <= 2)
{
request = request_local;
}
else
{
request = (char *) malloc (request_size);
if (request == NULL)
{
er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OUT_OF_VIRTUAL_MEMORY, 1, (size_t) request_size);
return ER_OUT_OF_VIRTUAL_MEMORY;
}
}
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_int_array (ptr, lob_attrid_arr_length, attrid_arr);
req_error =
net_client_request (NET_SERVER_LOB_CREATE_DIR, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error == NO_ERROR)
{
ptr = or_unpack_errcode (reply, &error);
}
if (request != request_local)
{
free_and_init (request);
}
return error;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
error = xlob_create_dir (thread_p, hfid, attrid_arr, lob_attrid_arr_length);
exit_server (*thread_p);
return error;
#endif /* CS_MODE */
}
/* lob_remove_dir - remove lob directory
*
* return: error code
*
* hfid(in): Used to identify the table when removing the LOB directory
* attrid(in): Used to identify the table's LOB attribute when removing the LOB directory
*/
int
lob_remove_dir (HFID * hfid, int attrid)
{
#if defined(CS_MODE)
char *ptr = NULL;
char *request = NULL;
OR_ALIGNED_BUF (OR_HFID_SIZE + OR_INT_SIZE) a_request;
char *reply = NULL;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
int req_error;
int error = ER_NET_CLIENT_DATA_RECEIVE;
assert (!HFID_IS_NULL (hfid) && hfid != NULL);
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
ptr = or_pack_hfid (request, hfid);
ptr = or_pack_int (ptr, attrid);
req_error =
net_client_request (NET_SERVER_LOB_REMOVE_DIR, request, OR_ALIGNED_BUF_SIZE (a_request), reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (req_error == NO_ERROR)
{
ptr = or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int error = NO_ERROR;
THREAD_ENTRY *thread_p = enter_server ();
error = xlob_remove_dir (thread_p, hfid, attrid);
exit_server (*thread_p);
return error;
#endif /* CS_MODE */
}
/*
* file_dump_file_list -
*
* return:
*
* outfp(in):
* invalid_file_only(in):
*/
int
file_dump_file_list (FILE * outfp, bool invalid_only)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) or_pack_int (request, (int) invalid_only);
req_error =
net_client_request_recv_stream (NET_SERVER_CLEANFILEDB_DUMP_FILE_LIST, request, OR_ALIGNED_BUF_SIZE (a_request),
reply, OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, outfp);
if (!req_error)
{
(void) or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xfile_tracker_dump_file_list (thread_p, outfp, invalid_only);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
/*
* file_clean_invalid_file -
*
* return:
*
* heap(out):
* heap_ovf(out):
* btree(out):
* btree_ovf(out):
*/
int
file_clean_invalid_file (int *heap, int *heap_ovf, int *btree, int *btree_ovf)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error;
OR_ALIGNED_BUF (OR_INT_SIZE * 5) a_reply;
char *reply, *ptr;
reply = OR_ALIGNED_BUF_START (a_reply);
req_error =
net_client_request (NET_SERVER_CLEANFILEDB_CLEAN_INVALID_FILE, NULL, 0, reply, OR_ALIGNED_BUF_SIZE (a_reply),
NULL, 0, NULL, 0);
if (!req_error)
{
ptr = or_unpack_errcode (reply, &error);
ptr = or_unpack_int (ptr, heap);
ptr = or_unpack_int (ptr, heap_ovf);
ptr = or_unpack_int (ptr, btree);
ptr = or_unpack_int (ptr, btree_ovf);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xfile_tracker_clean_invalid_file (thread_p, heap, heap_ovf, btree, btree_ovf);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
#if !defined(NDEBUG)
/*
* file_delete_target_file -
*
* return:
*/
int
file_delete_target_file (const char *target_vfid_str)
{
#if defined(CS_MODE)
int error = ER_NET_CLIENT_DATA_RECEIVE;
int req_error, request_size;
OR_ALIGNED_BUF (32) a_request;
char *request;
OR_ALIGNED_BUF (OR_INT_SIZE) a_reply;
char *reply;
request_size = length_const_string (target_vfid_str, NULL);
if (request_size > 32)
{
return ER_QPROC_INVALID_PARAMETER;
}
request = OR_ALIGNED_BUF_START (a_request);
reply = OR_ALIGNED_BUF_START (a_reply);
(void) pack_const_string (request, target_vfid_str);
req_error =
net_client_request (NET_SERVER_CLEANFILEDB_DELETE_TARGET_FILE, request, request_size, reply,
OR_ALIGNED_BUF_SIZE (a_reply), NULL, 0, NULL, 0);
if (!req_error)
{
(void) or_unpack_errcode (reply, &error);
}
return error;
#else /* CS_MODE */
int success;
THREAD_ENTRY *thread_p = enter_server ();
success = xfile_tracker_delete_target_file (thread_p, target_vfid_str);
exit_server (*thread_p);
return success;
#endif /* !CS_MODE */
}
#endif