view release on metacpan or  search on metacpan

cci-src/src/cci/cci_query_execute.c  view on Meta::CPAN

    }

  if (num_tuple < 0)
    {
      return 0;
    }
  else if (num_tuple == 0)
    {
      if (fetch_type == FETCH_FETCH && hm_get_broker_version (con_handle) >= CAS_PROTO_MAKE_VER (PROTOCOL_V5))
	{
	  if (remain_size < NET_SIZE_BYTE)
	    {
	      return CCI_ER_COMMUNICATION;
	    }

	  NET_STR_TO_BYTE (req_handle->is_fetch_completed, cur_p);
	  remain_size -= NET_SIZE_BYTE;
	  cur_p += NET_SIZE_BYTE;
	}

      return 0;
    }

  tmp_tuple_value = (T_TUPLE_VALUE *) MALLOC (sizeof (T_TUPLE_VALUE) * num_tuple);
  if (tmp_tuple_value == NULL)
    return CCI_ER_NO_MORE_MEMORY;
  memset ((char *) tmp_tuple_value, 0, sizeof (T_TUPLE_VALUE) * num_tuple);

  for (i = 0; i < num_tuple; i++)
    {
      if (fetch_type == FETCH_FETCH)
	{
	  if (remain_size < 4)
	    {
	      err_code = CCI_ER_COMMUNICATION;
	      goto fetch_info_decode_error;
	    }
	  NET_STR_TO_INT (tmp_tuple_value[i].tuple_index, cur_p);
	  cur_p += 4;
	  remain_size -= 4;

	  if (remain_size < NET_SIZE_OBJECT)
	    {
	      err_code = CCI_ER_COMMUNICATION;
	      goto fetch_info_decode_error;
	    }
	  stream_to_obj (cur_p, &(tmp_tuple_value[i].tuple_oid));
	  cur_p += NET_SIZE_OBJECT;
	  remain_size -= NET_SIZE_OBJECT;
	}

      tmp_tuple_value[i].column_ptr = (char **) MALLOC (sizeof (char *) * num_cols);
      if (tmp_tuple_value[i].column_ptr == NULL)
	{
	  err_code = CCI_ER_NO_MORE_MEMORY;
	  goto fetch_info_decode_error;
	}
      memset (tmp_tuple_value[i].column_ptr, '\0', sizeof (char *) * num_cols);

#if defined(WINDOWS)
      tmp_tuple_value[i].decoded_ptr = (char **) MALLOC (sizeof (char *) * num_cols);
      if (tmp_tuple_value[i].decoded_ptr == NULL)
	{
	  err_code = CCI_ER_NO_MORE_MEMORY;
	  goto fetch_info_decode_error;
	}
      memset (tmp_tuple_value[i].decoded_ptr, '\0', sizeof (char *) * num_cols);
#endif

      for (j = 0; j < num_cols; j++)
	{
	  int data_size;
	  char *col_p;
#if defined (WINDOWS)
	  T_CCI_U_TYPE u_type;
#endif

	  col_p = cur_p;
	  if (remain_size < 4)
	    {
	      err_code = CCI_ER_COMMUNICATION;
	      goto fetch_info_decode_error;
	    }
	  NET_STR_TO_INT (data_size, cur_p);
	  remain_size -= 4;
	  cur_p += 4;

	  if (remain_size < data_size)
	    {
	      err_code = CCI_ER_COMMUNICATION;
	      goto fetch_info_decode_error;
	    }

#if defined (WINDOWS)
	  if (charset != NULL)
	    {
	      u_type = get_basic_utype (req_handle->col_info[j].ext_type);
	    }

	  if (charset != NULL
	      && (u_type == CCI_U_TYPE_CHAR || u_type == CCI_U_TYPE_STRING || u_type == CCI_U_TYPE_NCHAR
		  || u_type == CCI_U_TYPE_VARNCHAR || u_type == CCI_U_TYPE_ENUM))
	    {
	      err_code = decode_result_col (col_p, data_size, &(tmp_tuple_value[i].column_ptr[j]), charset);

	      if (err_code < 0)
		{
		  goto fetch_info_decode_error;
		}
	      else if (err_code == 0)
		{
		  /* invalid character set. do not convert string */
		  tmp_tuple_value[i].column_ptr[j] = col_p;
		}
	      else
		{
		  tmp_tuple_value[i].decoded_ptr[j] = tmp_tuple_value[i].column_ptr[j];
		}
	    }
	  else
	    {
	      tmp_tuple_value[i].column_ptr[j] = col_p;
	    }
#else
	  tmp_tuple_value[i].column_ptr[j] = col_p;
#endif

	  if (data_size > 0)
	    {
	      cur_p += data_size;
	      remain_size -= data_size;
	    }
	}			/* end of for j */
    }				/* end of for i */

  if (fetch_type == FETCH_FETCH && hm_get_broker_version (con_handle) >= CAS_PROTO_MAKE_VER (PROTOCOL_V5))
    {
      if (remain_size < NET_SIZE_BYTE)
	{
	  return CCI_ER_COMMUNICATION;
	}

      NET_STR_TO_BYTE (req_handle->is_fetch_completed, cur_p);
      remain_size -= NET_SIZE_BYTE;
      cur_p += NET_SIZE_BYTE;
    }

  *tuple_value = tmp_tuple_value;

  return num_tuple;

fetch_info_decode_error:
  if (tmp_tuple_value)
    {
      for (i = 0; i < num_tuple; i++)
	{
#if defined (WINDOWS)
	  if (tmp_tuple_value[i].decoded_ptr)
	    {
	      for (j = 0; j < num_cols; j++)
		{
		  FREE_MEM (tmp_tuple_value[i].decoded_ptr[j]);
		}

	      FREE_MEM (tmp_tuple_value[i].decoded_ptr);
	    }
#endif
	  FREE_MEM (tmp_tuple_value[i].column_ptr);
	}
      FREE_MEM (tmp_tuple_value);
    }
  return err_code;
}

static void
stream_to_obj (char *buf, T_OBJECT * obj)
{
  int pageid;
  short volid, slotid;

  NET_STR_TO_INT (pageid, buf);
  NET_STR_TO_SHORT (slotid, buf + 4);
  NET_STR_TO_SHORT (volid, buf + 6);

  obj->pageid = pageid;
  obj->slotid = slotid;
  obj->volid = volid;
}

static int
get_data_set (T_CCI_U_EXT_TYPE u_ext_type, char *col_value_p, T_SET ** value, int data_size)
{
  T_SET *set;
  int ele_type;
  int num_element;
  int err_code;

  if ((err_code = t_set_alloc (&set)) < 0)
    {
      return err_code;
    }

  if (!(CCI_IS_COLLECTION_TYPE (u_ext_type)))
    {
      return CCI_ER_TYPE_CONVERSION;
    }

  ele_type = *col_value_p;
  col_value_p++;
  data_size--;
  NET_STR_TO_INT (num_element, col_value_p);
  col_value_p += 4;
  data_size -= 4;

  set->type = ele_type;
  set->num_element = num_element;

  set->data_buf = MALLOC (data_size);
  if (set->data_buf == NULL)
    {
      t_set_free (set);
      return CCI_ER_NO_MORE_MEMORY;
    }
  memcpy (set->data_buf, col_value_p, data_size);
  set->data_size = data_size;