dbe_key_t * setp_temp_key (setp_node_t * setp, long *row_len_ptr, int quietcast) { int inx = 0; NEW_VARZ (dbe_key_t, key); key->key_n_significant = dk_set_length (setp->setp_keys); key->key_id = KI_TEMP; key->key_is_primary = 0; key->key_super_id = KI_TEMP; DO_SET (state_slot_t *, ssl, &setp->setp_keys) { if (row_len_ptr) *row_len_ptr += sqt_row_data_length (& ssl->ssl_sqt); key_col_from_ssl (key, ssl, quietcast, NULL); } END_DO_SET(); DO_SET (state_slot_t *, ssl, &setp->setp_dependent) { gb_op_t *gb_op = dk_set_nth (setp->setp_gb_ops, inx); if (row_len_ptr) *row_len_ptr += sqt_row_data_length (& ssl->ssl_sqt); key_col_from_ssl (key, ssl, quietcast, gb_op); inx ++; } END_DO_SET(); dbe_key_layout (key, NULL); dk_set_push (&setp->src_gen.src_query->qr_temp_keys, (void*) key); return key; }
void * basket_remove_if (basket_t * bsk, basket_check_t f, void *cd) { int found = 0; void *remd = NULL; dk_set_t tmp = NULL; void *elt; #ifdef MTX_DEBUG if (bsk->bsk_req_mtx) ASSERT_IN_MTX (bsk->bsk_req_mtx); #endif while ((elt = basket_get (bsk))) { if (!found && f (elt, cd)) { remd = elt; found = 1; } else dk_set_push (&tmp, elt); } dk_set_nreverse (tmp); DO_SET (void *, x, &tmp) { basket_add (bsk, x); } END_DO_SET (); dk_set_free (tmp); return remd; }
dk_mutex_t * mutex_allocate (void) { NEW_VARZ (dk_mutex_t, mtx); mtx->mtx_handle = semaphore_allocate (1); #ifdef MTX_DEBUG mtx->mtx_owner = NULL; dk_set_push (&all_mtxs, (void*)mtx); #endif return mtx; }
dk_mutex_t * mutex_allocate_typed (int type) { int rc; static int is_initialized = 0; NEW_VARZ (dk_mutex_t, mtx); mtx->mtx_type = type; #if HAVE_SPINLOCK if (MUTEX_TYPE_SPIN == type) { pthread_spin_init (&mtx->l.spinl, 0); } else #endif { memset ((void *) &mtx->mtx_mtx, 0, sizeof (pthread_mutex_t)); #ifndef OLD_PTHREADS if (!is_initialized) { pthread_mutexattr_init (&_mutex_attr); #if defined (PTHREAD_PROCESS_PRIVATE) && !defined(oldlinux) && !defined (__FreeBSD__) rc = pthread_mutexattr_setpshared (&_mutex_attr, PTHREAD_PROCESS_PRIVATE); CKRET (rc); #endif #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP rc = pthread_mutexattr_settype (&_mutex_attr, PTHREAD_MUTEX_ADAPTIVE_NP); CKRET (rc); #endif is_initialized = 1; } rc = pthread_mutex_init (&mtx->mtx_mtx, &_mutex_attr); #else rc = pthread_mutex_init (&mtx->mtx_mtx, _mutex_attr); #endif CKRET (rc); } #ifdef MTX_DEBUG mtx->mtx_owner = NULL; #endif #ifdef MTX_METER if (all_mtxs_mtx) mutex_enter (all_mtxs_mtx); dk_set_push (&all_mtxs, (void*)mtx); if (all_mtxs_mtx) mutex_leave (all_mtxs_mtx); #endif return mtx; failed: dk_free (mtx, sizeof (dk_mutex_t)); return NULL; }
caddr_t * set_pos_param_row (cli_stmt_t * stmt, int nth) { int btype = stmt->stmt_bind_type; int n_cols = BOX_ELEMENTS (stmt->stmt_compilation->sc_columns); int iparam = 0; caddr_t *row = (caddr_t *) dk_alloc_box_zero (n_cols * sizeof (caddr_t), DV_ARRAY_OF_POINTER); col_binding_t *cb = stmt->stmt_cols; for (iparam = 0; iparam < n_cols; iparam++) { if (cb && cb->cb_place) { int c_type = cb->cb_c_type; char *place = cb->cb_place; SQLLEN *length = cb->cb_length; int rebind_offset = stmt->stmt_imp_row_descriptor ? (stmt->stmt_imp_row_descriptor->d_bind_offset_ptr ? *(stmt->stmt_imp_row_descriptor->d_bind_offset_ptr) : 0) : 0; place += btype == 0 ? nth * sqlc_sizeof (c_type, cb->cb_max_length) : nth * btype; place += rebind_offset; if (length) { *((char **) &length) += btype == 0 ? nth * sizeof (SDWORD) : btype * nth; *((char **) &length) += rebind_offset; } if (length && SQL_IGNORE == *length) row[iparam] = (dk_alloc_box (0, DV_IGNORE)); else { caddr_t v = buffer_to_dv (place, length, c_type, c_type, BHID (nth, iparam + 1), NULL, CON_IS_INPROCESS (stmt->stmt_connection)); row[iparam] = v; if (IS_BOX_POINTER (v) && DV_DAE == box_tag (v)) dk_set_push (&stmt->stmt_dae, &row[iparam]); } /* never a BLOB handle, since c_type never == SQL_ONGxx */ } else row[iparam] = dk_alloc_box (0, DV_IGNORE); if (cb) cb = cb->cb_next; } return row; }
void mpschema_set_view_def (char *name, caddr_t tree) { caddr_t *old_tree = NULL; old_tree = (caddr_t *) id_hash_get (xml_global->xs_views, (caddr_t) &name); if (old_tree) { if (*old_tree) { if (*old_tree == tree) GPF_T; dk_set_push (xml_global->xs_old_views, *old_tree); } *old_tree = tree; } else { name = box_dv_short_string (name); id_hash_set (xml_global->xs_views, (caddr_t) & name, (caddr_t) & tree); } }
dk_set_t bh_string_list_w (/* this was before 3.0: index_space_t * isp,*/ lock_trx_t * lt, blob_handle_t * bh, long get_chars, int omit, long blob_type) { /* take current page at current place and make string of n bytes from the place and write to client */ caddr_t page_string; dk_set_t string_list = NULL; dp_addr_t start = bh->bh_current_page; buffer_desc_t *buf = NULL; long from_char = bh->bh_position; long chars_filled = 0, chars_on_page; virt_mbstate_t state; wchar_t wpage[PAGE_SZ]; #if 0 /* this was */ it_cursor_t *tmp_itc = itc_create (isp, lt); #else it_cursor_t *tmp_itc = itc_create (NULL, lt); itc_from_it (tmp_itc, bh->bh_it); #endif while (start) { long char_len, byte_len, next; unsigned char *mbc; uint32 timestamp; int type; memset (&state, 0, sizeof (state)); if (!page_wait_blob_access (tmp_itc, start, &buf, PA_READ, bh, 1)) break; type = SHORT_REF (buf->bd_buffer + DP_FLAGS); timestamp = LONG_REF (buf->bd_buffer + DP_BLOB_TS); if ((DPF_BLOB != type) && (DPF_BLOB_DIR != type)) { page_leave_outside_map (buf); dbg_printf (("wrong blob type\n")); return 0; } if ((bh->bh_timestamp != BH_ANY) && (timestamp != bh->bh_timestamp)) { page_leave_outside_map (buf); return BH_DIRTYREAD; } byte_len = LONG_REF (buf->bd_buffer + DP_BLOB_LEN); mbc = buf->bd_buffer + DP_DATA; char_len = (long) virt_mbsnrtowcs (wpage, &mbc, byte_len, PAGE_DATA_SZ, &state); if (char_len < 0) GPF_T1 ("bad UTF8 data in wide blob page"); chars_on_page = MIN (char_len - from_char, get_chars); if (chars_on_page) { /* dbg_printf (("Read blob page %ld, %ld bytes.\n", start, bytes_on_page)); */ if (!omit) { if (DK_MEM_RESERVE) { SET_DK_MEM_RESERVE_STATE (lt); itc_bust_this_trx (tmp_itc, &buf, ITC_BUST_THROW); } page_string = dk_alloc_box ((chars_on_page + 1) * sizeof(wchar_t), DV_WIDE); memcpy (page_string, wpage + from_char, chars_on_page * sizeof (wchar_t)); ((wchar_t *)page_string)[chars_on_page] = 0; dk_set_push (&string_list, page_string); } chars_filled += chars_on_page; get_chars -= chars_on_page; from_char += chars_on_page; } next = LONG_REF (buf->bd_buffer + DP_OVERFLOW); page_leave_outside_map (buf); if (0 == get_chars) { bh->bh_position = from_char; break; } bh->bh_current_page = next; bh->bh_position = 0; from_char = 0; start = next; } itc_free (tmp_itc); return (dk_set_nreverse (string_list)); }
static caddr_t sa_to_dk (MonoArray *mono_list, int ofs, int mode, void *udt) { guint32 ret_type; int clr_object = 0; MonoObject *type, *value; caddr_t ret = NULL; MonoClass *cls; int len = mono_array_length (mono_list), inx; dk_set_t ret_set = NULL; type = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 0); ret_type = *(guint32 *)((char *)type + sizeof (MonoObject)); if (!ret_type) { char *error_text; caddr_t err = NULL; value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + 1); error_text = mono_string_to_utf8 ((MonoString *)value); if (error_text) err = srv_make_new_error ("42000", "MN002", "Mono error : %.200s", mono_class_get_name (mono_object_get_class (value)), error_text); else err = srv_make_new_error ("42000", "MN003", "Unknown mono error"); g_free (error_text); sqlr_resignal (err); } /* get type of object */ clr_object = 0; if (ret_type == 5 || ret_type == 6) clr_object = 1; for (inx = 1; inx < len; inx++) { value = (MonoObject *)mono_array_get (mono_list, gpointer, ofs + inx); if (value) { cls = mono_object_get_class (value); if (cls == mono_get_int32_class ()) { gint32 v = *(gint32 *)((char *)value + sizeof (MonoObject)); if (clr_object) { void * what_udt; if (mode) { /*add_id (v);*/ ret = box_num (v); } else { what_udt = udt_find_class_for_clr_instance (v, udt); if (what_udt) { /*add_id (v);*/ ret = cpp_udt_clr_instance_allocate (v, what_udt); } else { sqlr_new_error ("22023", "MN005", "Can't map Mono result to PL type"); } } } else ret = box_num (v); } else if (cls == mono_get_uint32_class()) ret = box_num (*(guint32 *)((char *)value + sizeof (MonoObject))); else if (cls == mono_get_single_class ()) ret = box_float (*(float *)((char *)value + sizeof (MonoObject))); else if (cls == mono_get_double_class ()) ret = box_double (*(double *)((char *)value + sizeof (MonoObject))); else if (cls == mono_get_boolean_class ()) ret = box_num (*(guint8 *)((guint8 *)value + sizeof (MonoObject))); else if (cls == mono_get_string_class ()) { char *utf8 = mono_string_to_utf8 ((MonoString *)value); ret = box_utf8_as_wide_char (utf8, NULL, strlen (utf8), 0, DV_WIDE); g_free (utf8); } else { const char *name = mono_class_get_name (cls); sqlr_new_error ("22023", "MN006", "Can't map CLR result of type (%s) to PL type", name ? name : "<unknown>"); } } else ret = NULL; if (ret_type != 3 && ret_type != 4 && ret_type != 5) return ret; else dk_set_push (&ret_set, ret); } return list_to_array (dk_set_nreverse (ret_set)); }