コード例 #1
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * add_method_internal() - This is internal work function to add a method
 *                         definition.
 * return : error code
 * class(in) : class or instance
 * name(in): method name
 * implementation(in): implementation function name
 * namespace(in): attribute or class namespace identifier
 */
static int
add_method_internal (MOP class_, const char *name, const char *implementation, SM_NAME_SPACE name_space)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_2ARGS_RETURN_EXPR (class_, name, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_add_method_any (def, name, implementation, name_space);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class_auto (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }
  return (error);
}
コード例 #2
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_set_loader_commands() - This function sets the dynamic linking loader
 *    command string for a class. This is usually a list of library names that
 *    are to be included when linking the methods for a particular class.
 * return : error code
 * class(in): class or instance
 * commands(in): link command string
 *
 * note : The format of this string must be suitable for insertion in the
 *    command line of the UNIX ld command (link editor), such as
 *      "-L /usr/local/lib -l utilities"
 */
int
db_set_loader_commands (MOP class_, const char *commands)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;

  CHECK_CONNECT_ERROR ();
  CHECK_1ARG_ERROR (class_);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_set_loader_commands (def, commands);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class (def, NULL);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }

  return (error);
}
コード例 #3
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_drop_constraint() - This function is used remove constraint from a class.
 *    Please refer to the header information for db_add_constraint() for basic
 *    information on classes and constraints.
 * return : error code
 * classmop: class (or instance) pointer
 * constraint_type: type of constraint to drop
 * constraint_name: constraint name
 * att_names: names of attributes to be constrained
 * class_attributes: flag indicating class attribute status
 *                  (0 if this is not a class attribute,
 *                   non-zero if this is a class attribute)
 *
 * note :
 *    If the name is known, the constraint can be dropped by name, in which
 *    case the <att_names> parameter should be NULL.
 *    If the name is not known, the constraint can be specified by the
 *    combination of class pointer and attribute names.
 *    The order of the attribute names must match the order given when the
 *    constraint was added. In this case, the <constraint_name> should be NULL.
 */
int
db_drop_constraint (MOP classmop, DB_CONSTRAINT_TYPE constraint_type, const char *constraint_name,
		    const char **att_names, int class_attributes)
{
  int retval;
  char *name = NULL;

  CHECK_CONNECT_ERROR ();
  CHECK_1ARG_ERROR (classmop);
  CHECK_MODIFICATION_ERROR ();

  name = sm_produce_constraint_name_mop (classmop, constraint_type, att_names, NULL, constraint_name);

  if (name == NULL)
    {
      assert (er_errid () != NO_ERROR);
      retval = er_errid ();
    }
  else
    {
      retval = sm_drop_constraint (classmop, constraint_type, name, att_names, class_attributes ? true : false, false);
      free_and_init (name);
    }

  return (retval);
}
コード例 #4
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_change_default() - This function changes the default value definition of
 *    an attribute. Default values are normally established when the attribute
 *    is first defined using the db_add_attribute() function. This function
 *    can be used to change the default value after the attribute has been
 *    defined.
 * return : error code
 * class(in): class or instance pointer
 * name(in) : attribute name
 * value(in): value container with value
 *
 * note: Do not use this function to change the values of class attributes.
 *       Instead, the db_put() function is used with the class object as the
 *       first argument.
 */
int
db_change_default (MOP class_, const char *name, DB_VALUE * value)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_3ARGS_RETURN_EXPR (class_, name, value, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_set_attribute_default (def, name, false, value, DB_DEFAULT_NONE);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }
  return (error);
}
コード例 #5
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_rename_internal() - This will rename any of the various class components:
 *    attributes, class attributes, methods, class methods.
 * return : error code
 * class(in)   : class to alter
 * name(in)    : component name
 * class_namespace(in): class namespace flag
 * newname(in) : new component name
 */
int
db_rename_internal (MOP class_, const char *name, int class_namespace, const char *newname)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_rename_any (def, name, class_namespace, newname);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class_auto (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }

  return (error);
}
コード例 #6
0
ファイル: loader_disk.c プロジェクト: dong1/testsize
/*
 * disk_reserve_instance - This is used to reserve space for an instance that
 * was referenced in the load file but has not yet been defined.
 *    return: NO_ERROR if successful, error code otherwise
 *    classop(in): class
 *    oid(in): returned instance OID
 */
int
disk_reserve_instance (MOP classop, OID * oid)
{
  int error = NO_ERROR;
  SM_CLASS *class_;
  HFID *hfid;
  int expected;

  class_ = (SM_CLASS *) locator_fetch_class (classop, DB_FETCH_READ);
  if (class_ == NULL)
    {
      error = er_errid ();
    }
  else
    {
      expected = estimate_object_size (class_);
      hfid = get_class_heap (classop, class_);
      if (hfid == NULL)
	{
	  error = er_errid ();
	}
      else
	{
	  if (heap_assign_address_with_class_oid (NULL, hfid, oid, expected,
						  ws_oid (classop)) !=
	      NO_ERROR)
	    {
	      error = ER_LDR_CANT_INSERT;
	      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, error, 0);
	    }
	}
    }

  return error;
}
コード例 #7
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_change_method_implementation() - This function changes the name of C
 *    function that is called when the method is invoked.
 * returns/side-effects: error code
 * class(in)   : class or instance
 * name(in)    : method name
 * class_method(in): class method flag
 * newname(in) : new interface function name
 */
int
db_change_method_implementation (MOP class_, const char *name, int class_method, const char *newname)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_3ARGS_RETURN_EXPR (class_, name, newname, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_change_method_implementation (def, name, class_method, newname);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }
  return (error);
}
コード例 #8
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_drop_class_resolution() - This function removes a class-level resolution.
 * returns : error code
 * class(in): class pointer
 * super(in): class pointer
 * name(in): attribute/method name
 */
int
db_drop_class_resolution (MOP class_, MOP super, const char *name)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_delete_class_resolution (def, super, name);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class_auto (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }

  return (error);
}
コード例 #9
0
ファイル: query_result.c プロジェクト: CUBRID/cubrid
/*
 * pt_report_to_ersys_with_statement () - report query compilation error by
 *                                        setting global ER state
 *   return:
 *   parser(in): handle to parser used to process the query
 *   error_type(in): syntax, semantic, or execution
 *   statement(in): statement tree
 */
void
pt_report_to_ersys_with_statement (PARSER_CONTEXT * parser, const PT_ERROR_TYPE error_type, PT_NODE * statement)
{
  PT_NODE *error_node;
  char buf[1000];
  char *stmt_string = NULL;
  int err;

  if (parser == NULL)
    {
      return;
    }

  error_node = parser->error_msgs;
  if (statement)
    {
      PT_NODE_PRINT_TO_ALIAS (parser, statement, PT_CONVERT_RANGE | PT_SHORT_PRINT);
      stmt_string = (char *) statement->alias_print;
    }
  if (stmt_string == NULL)
    {
      stmt_string = (char *) "";
    }

  if (error_node && error_node->node_type == PT_ZZ_ERROR_MSG)
    {
#if 0				/* TODO */
      assert (er_errid () != NO_ERROR);
#endif
      err = er_errid ();
      if (!ER_IS_LOCK_TIMEOUT_ERROR (err) && !ER_IS_SERVER_DOWN_ERROR (err))
	{
	  switch (error_type)
	    {
	    case PT_SYNTAX:
	      er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_SYNTAX, 2,
		      error_node->info.error_msg.error_message, stmt_string);
	      break;
	    case PT_SEMANTIC:
	    default:
	      er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_SEMANTIC, 2,
		      error_node->info.error_msg.error_message, stmt_string);
	      break;
	    case PT_EXECUTION:
	      er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_EXECUTE, 2,
		      error_node->info.error_msg.error_message, stmt_string);
	      break;
	    }
	}
      return;
    }

  /* a system error reporting error messages */
  sprintf (buf, "Internal error- reporting %s error.",
	   (error_type == PT_SYNTAX ? "syntax" : (error_type == PT_SEMANTIC ? "semantic" : "execution")));

  er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_EXECUTE, 2, buf, stmt_string);
}				/* pt_report_to_ersys_with_statement() */
コード例 #10
0
ファイル: loader_disk.c プロジェクト: BogdanStroe/cubrid
/*
 * disk_insert_instance - This inserts a new object in the database given a
 * "descriptor" for the object.
 *    return: NO_ERROR if successful, error code otherwise
 *    classop(in): class object
 *    obj(in): object description
 *    oid(in): oid of the destination
 */
int
disk_insert_instance (MOP classop, DESC_OBJ * obj, OID * oid)
{
  int error = NO_ERROR;
  HFID *hfid;
  int newsize;
  bool has_indexes;

  Diskrec->length = 0;
  if (desc_obj_to_disk (obj, Diskrec, &has_indexes))
    {
      /* make the record larger */
      newsize = -Diskrec->length + DB_PAGESIZE;
      free_recdes (Diskrec);
      Diskrec = alloc_recdes (newsize);
      /* try one more time */
      if (Diskrec == NULL || desc_obj_to_disk (obj, Diskrec, &has_indexes) != 0)
	{
	  error = ER_LDR_CANT_TRANSFORM;
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, error, 0);
	}
    }

  if (!error)
    {
      hfid = get_class_heap (classop, obj->class_);
      if (hfid == NULL)
	{
	  assert (er_errid () != NO_ERROR);
	  error = er_errid ();
	}
      else
	{
	  HEAP_OPERATION_CONTEXT context;

	  /* set up context */
	  heap_create_insert_context (&context, hfid, WS_OID (classop), Diskrec, NULL, false);

	  /* oid is set here as a side effect */
	  if (heap_insert_logical (NULL, &context) != NO_ERROR)
	    {
	      assert (er_errid () != NO_ERROR);
	      error = er_errid ();
	    }
	  else if (has_indexes)
	    {
	      COPY_OID (oid, &context.res_oid);
	      error = update_indexes (WS_OID (classop), oid, Diskrec);
	    }
	  else
	    {
	      COPY_OID (oid, &context.res_oid);
	    }
	}
    }
  return (error);
}
コード例 #11
0
ファイル: show_meta.c プロジェクト: BogdanStroe/cubrid
/*
 * init_db_attribute_list () : init DB_ATTRIBUTE list for each show statement
 *   return: error code
 *   md(in/out):
 */
static int
init_db_attribute_list (SHOWSTMT_METADATA * md)
{
  int i;
  DB_DOMAIN *domain;
  DB_ATTRIBUTE *attrs = NULL, *att;

  if (md == NULL)
    {
      return NO_ERROR;
    }

  for (i = md->num_cols - 1; i >= 0; i--)
    {
      domain = pt_string_to_db_domain (md->cols[i].type, NULL);
      if (domain == NULL)
	{
	  goto on_error;
	}
      domain = tp_domain_cache (domain);

      att = classobj_make_attribute (md->cols[i].name, domain->type, ID_ATTRIBUTE);
      if (att == NULL)
	{
	  goto on_error;
	}
      att->domain = domain;
      att->auto_increment = NULL;

      if (attrs == NULL)
	{
	  attrs = att;
	}
      else
	{
	  att->order_link = attrs;
	  attrs = att;
	}
    }

  md->showstmt_attrs = attrs;
  return NO_ERROR;

on_error:
  while (attrs != NULL)
    {
      att = attrs;
      attrs = (DB_ATTRIBUTE *) att->order_link;
      att->order_link = NULL;

      classobj_free_attribute (att);
    }

  assert (er_errid () != NO_ERROR);
  return er_errid ();
}
コード例 #12
0
ファイル: loader_disk.c プロジェクト: BogdanStroe/cubrid
/*
 * disk_update_instance - This updates an object that had previously been
 * reserved with the actual contents.
 *    return: NO_ERROR if successful, error code otherwise
 *    classop(in): class object
 *    obj(in): description of object
 *    oid(in): destination oid
 */
int
disk_update_instance (MOP classop, DESC_OBJ * obj, OID * oid)
{
  int error = NO_ERROR;
  HFID *hfid;
  int newsize;
  bool has_indexes = false;

  Diskrec->length = 0;
  if (desc_obj_to_disk (obj, Diskrec, &has_indexes))
    {
      /* make the record larger */
      newsize = -Diskrec->length + DB_PAGESIZE;
      free_recdes (Diskrec);
      Diskrec = alloc_recdes (newsize);
      /* try one more time */
      if (Diskrec == NULL || desc_obj_to_disk (obj, Diskrec, &has_indexes) != 0)
	{
	  error = ER_LDR_CANT_TRANSFORM;
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, error, 0);
	}
    }
  if (!error)
    {
      hfid = get_class_heap (classop, obj->class_);
      if (hfid == NULL)
	{
	  assert (er_errid () != NO_ERROR);
	  error = er_errid ();
	}
      else
	{
	  HEAP_OPERATION_CONTEXT update_context;

	  heap_create_update_context (&update_context, hfid, oid, WS_OID (classop), Diskrec, NULL, UPDATE_INPLACE_NONE);

	  if (heap_update_logical (NULL, &update_context) != NO_ERROR)
	    {
	      assert (er_errid () != NO_ERROR);
	      error = er_errid ();
	    }

	  if (update_context.is_logical_old)
	    {
	      fprintf (stdout,
		       msgcat_message (MSGCAT_CATALOG_UTILS, MSGCAT_UTIL_SET_LOADDB, LOADDB_MSG_UPDATE_WARNING));
	    }
	  else if (has_indexes)
	    {
	      error = update_indexes (WS_OID (classop), oid, Diskrec);
	    }
	}
    }

  return (error);
}
コード例 #13
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_add_attribute_internal() - This is a generic work function for adding
 *    attributes of the various types.  It saves redundant error checking code
 *    in each of the type specific attribute routines.
 * return : error code
 * class(in/out) : class object
 * name(in)      : attribute name
 * domain(in)    : domain string
 * default_value(in): default_value
 * namespace(in) : namespace identifier
 */
int
db_add_attribute_internal (MOP class_, const char *name, const char *domain, DB_VALUE * default_value,
			   SM_NAME_SPACE name_space)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_3ARGS_RETURN_EXPR (class_, name, domain, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_add_attribute_any (def, name, domain, (DB_DOMAIN *) 0, name_space, false, NULL);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  if (default_value != NULL)
	    {
	      if (name_space == ID_CLASS || name_space == ID_CLASS_ATTRIBUTE)
		{
		  error = smt_set_attribute_default (def, name, 1, default_value, DB_DEFAULT_NONE);
		}
	      else
		{
		  error = smt_set_attribute_default (def, name, 0, default_value, DB_DEFAULT_NONE);
		}
	    }
	  if (error)
	    {
	      smt_quit (def);
	    }
	  else
	    {
	      error = sm_update_class_auto (def, &newmop);
	      if (error)
		{
		  smt_quit (def);
		}
	    }
	}
    }
  return (error);
}
コード例 #14
0
ファイル: loader_disk.c プロジェクト: BogdanStroe/cubrid
/*
 * disk_init - Initializes the loader's disk access module.
 *    return: NO_ERROR if successful, error code otherwise
 */
int
disk_init (void)
{
  int error = NO_ERROR;

  Diskrec = alloc_recdes (DB_PAGESIZE * 4);
  if (Diskrec == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  return error;
}
コード例 #15
0
ファイル: loader_disk.c プロジェクト: dong1/testsize
/*
 * disk_update_instance - This updates an object that had previously been
 * reserved with the acutal contents.
 *    return: NO_ERROR if successful, error code otherwise
 *    classop(in): class object
 *    obj(in): description of object
 *    oid(in): destination oid
 */
int
disk_update_instance (MOP classop, DESC_OBJ * obj, OID * oid)
{
  int error = NO_ERROR;
  HFID *hfid;
  int newsize;
  bool has_indexes = false, oldflag;

  Diskrec->length = 0;
  if (desc_obj_to_disk (obj, Diskrec, &has_indexes))
    {
      /* make the record larger */
      newsize = -Diskrec->length + DB_PAGESIZE;
      free_recdes (Diskrec);
      Diskrec = alloc_recdes (newsize);
      /* try one more time */
      if (Diskrec == NULL
	  || desc_obj_to_disk (obj, Diskrec, &has_indexes) != 0)
	{
	  error = ER_LDR_CANT_TRANSFORM;
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, error, 0);
	}
    }
  if (!error)
    {
      hfid = get_class_heap (classop, obj->class_);
      if (hfid == NULL)
	{
	  error = er_errid ();
	}
      else if (heap_update (NULL, hfid, oid, Diskrec, &oldflag, NULL) != oid)
	{
	  error = er_errid ();
	}
      else
	{
	  if (oldflag)
	    {
	      fprintf (stdout, msgcat_message (MSGCAT_CATALOG_UTILS,
					       MSGCAT_UTIL_SET_LOADDB,
					       LOADDB_MSG_UPDATE_WARNING));
	    }
	  else if (has_indexes)
	    {
	      error = update_indexes (WS_OID (classop), oid, Diskrec);
	    }
	}
    }

  return (error);
}
コード例 #16
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * add_arg_domain() - This function describes the domain of a method argument
 *    used for run time consistency checking by the interpreter. If the index
 *    argument is 0, the domain is used as the domain of the return value of
 *    the method. Otherwise, the index references the arguments of the method
 *    from 1 to n.
 * return : error code
 * class(in): class object
 * name(in): method name
 * class_method(in): class method flag
 * index(in): argument index (zero is return value)
 * initial_domain(in): initialize flag.
 * domain(in): domain descriptor string
 *
 * note : Argument indexes can be specified that do not necessarily increase
 *        by 1, i.e., arg1, arg2, arg5 leaves arg3 and arg4 unspecified and
 *        logically void.
 *        If the supplied index is greater than any of the indexes that were
 *        previously supplied for the arguments, the argument list of the
 *        method is extended.
 */
static int
add_arg_domain (DB_OBJECT * class_, const char *name, int class_method, int index, int initial_domain,
		const char *domain)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_2ARGS_RETURN_EXPR (class_, name, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      if (domain == NULL)
	{
	  error = smt_assign_argument_domain (def, name, class_method, NULL, index, NULL, (DB_DOMAIN *) 0);
	}
      else
	{
	  if (initial_domain)
	    {
	      error = smt_assign_argument_domain (def, name, class_method, NULL, index, domain, (DB_DOMAIN *) 0);
	    }
	  else
	    {
	      error = smt_add_set_argument_domain (def, name, class_method, NULL, index, domain, (DB_DOMAIN *) 0);
	    }
	}
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }
  return (error);
}
コード例 #17
0
/*
 * logwr_flush_header_page -
 *
 * return:
 * Note:
 */
void
logwr_flush_header_page (void)
{
  PAGEID phy_pageid;
  PAGEID logical_pageid;
  int nbytes;

  if (logwr_Gl.loghdr_pgptr == NULL)
    {
      return;
    }

  /* flush current archiving status */
  logwr_Gl.hdr.nxarv_num = logwr_Gl.last_arv_num;
  logwr_Gl.hdr.last_deleted_arv_num = logwr_Gl.last_deleted_arv_num;
  logwr_Gl.hdr.nxarv_pageid = logwr_Gl.last_arv_fpageid;
  logwr_Gl.hdr.nxarv_phy_pageid
    = logwr_to_physical_pageid (logwr_Gl.last_arv_fpageid);

  memcpy (logwr_Gl.loghdr_pgptr->area, &logwr_Gl.hdr, sizeof (logwr_Gl.hdr));

  logical_pageid = LOGPB_HEADER_PAGE_ID;
  phy_pageid = logwr_to_physical_pageid (logical_pageid);

  /* logwr_Gl.append_vdes is only changed
   * while starting or finishing or recovering server.
   * So, log cs is not needed.
   */
  if (fileio_write (NULL, logwr_Gl.append_vdes, logwr_Gl.loghdr_pgptr,
		    phy_pageid, LOG_PAGESIZE) == NULL
      || (logwr_Gl.mode != LOGWR_MODE_ASYNC
	  && fileio_synchronize (NULL, logwr_Gl.append_vdes,
				 logwr_Gl.active_name)) == NULL_VOLDES)
    {

      if (er_errid () == ER_IO_WRITE_OUT_OF_SPACE)
	{
	  nbytes = ((logwr_Gl.hdr.npages + 1 - logical_pageid) *
		    logwr_Gl.hdr.db_logpagesize);
	  er_set (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE,
		  ER_LOG_WRITE_OUT_OF_SPACE, 4, logical_pageid, phy_pageid,
		  logwr_Gl.active_name, nbytes);
	}
      else
	{
	  er_set_with_oserror (ER_FATAL_ERROR_SEVERITY, ARG_FILE_LINE,
			       ER_LOG_WRITE, 3, logical_pageid, phy_pageid,
			       logwr_Gl.active_name);
	}
    }

  /* save last checkpoint pageid */
  logwr_Gl.last_chkpt_pageid = logwr_Gl.hdr.chkpt_lsa.pageid;

  er_log_debug (ARG_FILE_LINE,
		"logwr_flush_header_page, ha_server_state=%s, ha_file_status=%s\n",
		css_ha_server_state_string (logwr_Gl.hdr.ha_server_state),
		logwr_Gl.hdr.ha_file_status ==
		LOG_HA_FILESTAT_SYNCHRONIZED ? "sync" : "unsync");
}
コード例 #18
0
ファイル: loader_object_table.c プロジェクト: dong1/testsize
/*
 * realloc_instance_table - Extends the instance array within a CLASS_TABLE.
 *    return: NO_ERROR if successful, error code otherwise
 *    table(in/out): class table to extend
 *    newcount(in): new size of the instance table
 */
static int
realloc_instance_table (CLASS_TABLE * table, int newcount)
{
  INST_INFO *tmp_inst_info;
  int i;

  /*
   * only do this if the new count is larger than the existing
   * table, shouldn't see this
   */
  if (newcount > table->count)
    {
      tmp_inst_info =
	(INST_INFO *) realloc (table->instances,
			       newcount * sizeof (INST_INFO));
      if (tmp_inst_info == NULL)
	{
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_LDR_MEMORY_ERROR, 0);
	  return er_errid ();
	}

      for (i = table->count; i < newcount; i++)
	{
	  tmp_inst_info[i].flags = 0;
	  OID_SET_NULL (&(tmp_inst_info[i].oid));
	}

      table->instances = tmp_inst_info;
      table->count = newcount;
    }
  return NO_ERROR;
}
コード例 #19
0
/*
 * overflow_delete_internal () -
 *   return: NO_ERROR
 *   ovf_vfid(in): File where the overflow data is stored
 *                 WARNING: MUST BE THE SAME AS IT WAS GIVEN DURING INSERT
 *   vpid(in):
 *   pgptr(in):
 */
static int
overflow_delete_internal (THREAD_ENTRY * thread_p, const VFID * ovf_vfid,
			  VPID * vpid, PAGE_PTR pgptr)
{
  int ret;

  ret = pgbuf_invalidate (thread_p, pgptr);
  if (ret != NO_ERROR)
    {
      goto exit_on_error;
    }

  ret = file_dealloc_page (thread_p, ovf_vfid, vpid);
  if (ret != NO_ERROR)
    {
      goto exit_on_error;
    }

  return ret;

exit_on_error:

  return (ret == NO_ERROR
	  && (ret = er_errid ()) == NO_ERROR) ? ER_FAILED : ret;
}
コード例 #20
0
ファイル: loader_disk.c プロジェクト: BogdanStroe/cubrid
/*
 * update_indexes - Updates the indexes for an instance that is being inserted.
 *    return: NO_ERROR if successful, error code otherwise
 *    class_oid(in): class oid
 *    obj_oid(in): instance oid
 *    rec(in): record with new object
 * Note:
 *    Updates the indexes for an instance that is being inserted.
 *    This only calls btree_insert because for use in the loader, we will never
 *    be updating existing instances.  When the loader encounters a forward
 *    reference to an instance, it will use heap_reserve_address but will
 *    not attempt to store a default instance at that address.
 *    This means that there will never be an existing entry in the btree when
 *    we finally get around to storing the actual object contents.  If this
 *    situation ever changes, then we will need to call btree_update here
 *    instead.  This will require the current key value which must be
 *    extracted from the hf record being replaced.
 *    See locator_force to see how this can be done.
 *
 *    Moral, avoid writing the instance record until absolutely necessary,
 *    and then do it only once.
 */
static int
update_indexes (OID * class_oid, OID * obj_oid, RECDES * rec)
{
  int error = NO_ERROR;

  if (locator_add_or_remove_index (NULL, rec, obj_oid, class_oid, true, SINGLE_ROW_INSERT, (HEAP_SCANCACHE *) NULL,
				   /* ejin: for replication... */
				   false,	/* 7th arg -> data or schema */
				   false, NULL,	/* 8th arg -> make repl. log or not */
				   NULL) != NO_ERROR)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }

  return error;
}
コード例 #21
0
ファイル: network_s2s.c プロジェクト: dong1/testsize
static int
set_server_error (int error)
{
  int server_error;

  switch (error)
    {
    case CANT_ALLOC_BUFFER:
      server_error = ER_NET_CANT_ALLOC_BUFFER;
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, server_error, 0);
      break;
    case RECORD_TRUNCATED:
      server_error = ER_NET_DATA_TRUNCATED;
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, server_error, 0);
      break;
    case REQUEST_REFUSED:
      server_error = er_errid ();
      break;
    case SERVER_ABORTED:
      server_error = er_errid ();
      /* those errors are generated by the net_server_request()
       * so that do not fall to server crash handling */
      switch (server_error)
	{
	case ER_DB_NO_MODIFICATIONS:
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, server_error, 0);
	  return (server_error);
	case ER_AU_DBA_ONLY:
	  er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, server_error, 1, "");
	  return (server_error);
	}
      /* no break; fall through */
    default:
      server_error = ER_NET_SERVER_CRASHED;
      er_set_with_oserror (ER_ERROR_SEVERITY, ARG_FILE_LINE, server_error, 0);
      break;
    }

  er_log_debug (ARG_FILE_LINE, "set_server_error(%d) server_error %d\n",
		error, server_error);

  db_Connect_status = DB_CONNECTION_STATUS_NOT_CONNECTED;

  return (server_error);
}
コード例 #22
0
ファイル: query_result.c プロジェクト: CUBRID/cubrid
/*
 * pt_report_to_ersys () - report query compilation error by
 *                         setting global ER state
 *   return:
 *   parser(in): handle to parser used to process the query
 *   error_type(in): syntax, semantic, or execution
 */
void
pt_report_to_ersys (const PARSER_CONTEXT * parser, const PT_ERROR_TYPE error_type)
{
  PT_NODE *error_node;
  int err;
  char buf[1000];

  error_node = parser->error_msgs;
  if (error_node && error_node->node_type == PT_ZZ_ERROR_MSG)
    {
#if 0				/* TODO */
      assert (er_errid () != NO_ERROR);
#endif
      err = er_errid ();
      if (!ER_IS_LOCK_TIMEOUT_ERROR (err) && !ER_IS_SERVER_DOWN_ERROR (err))
	{
	  switch (error_type)
	    {
	    case PT_SYNTAX:
	      er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_SYNTAX, 2,
		      error_node->info.error_msg.error_message, "");
	      break;
	    case PT_SEMANTIC:
	    default:
	      er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_SEMANTIC, 2,
		      error_node->info.error_msg.error_message, "");
	      break;
	    case PT_EXECUTION:
	      er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_EXECUTE, 2,
		      error_node->info.error_msg.error_message, "");
	      break;
	    }
	}
      return;
    }

  /* a system error reporting error messages */
  sprintf (buf, "Internal error- reporting %s error.",
	   (error_type == PT_SYNTAX ? "syntax" : (error_type == PT_SEMANTIC ? "semantic" : "execution")));

  er_set (ER_SYNTAX_ERROR_SEVERITY, ARG_FILE_LINE, ER_PT_EXECUTE, 2, buf, "");
}
コード例 #23
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_drop_super() - This function removes a superclass link from a class.
 *    The attributes and methods that were inherited from the superclass are
 *    removed, and the changes are propagated to the subclasses. If the class
 *    is partitioned, function returns ER_NOT_ALLOWED_ACCESS_TO_PARTITION.
 * return : error code
 * class(in): class or instance pointer
 * super(in): class pointer
 *
 * note : Any resulting conflicts are resolved automatically by the system.
 *      If the system's resolution is unsatisfactory, it can be redefined
 *      with the db_add_resolution() function or the db_add_class_resolution()
 *      function, as appropriate.
 */
int
db_drop_super (MOP class_, MOP super)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_2ARGS_RETURN_EXPR (class_, super, ER_OBJ_INVALID_ARGUMENTS);

  error = do_check_partitioned_class (class_, CHECK_PARTITION_SUBS, NULL);
  if (!error)
    {
      def = smt_edit_class_mop (class_, AU_ALTER);
      if (def == NULL)
	{
	  assert (er_errid () != NO_ERROR);
	  error = er_errid ();
	}
      else
	{
	  error = smt_delete_super (def, super);
	  if (error)
	    {
	      smt_quit (def);
	    }
	  else
	    {
	      error = sm_update_class_auto (def, &newmop);
	      if (error)
		{
		  smt_quit (def);
		}
	    }
	}
    }

  return (error);
}
コード例 #24
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_drop_set_attribute_domain() - This function used to remove domain
 *    specifications for attributes whose original domain was "set",
 *    "multi_set", or "sequence". The set valued attributes can be given
 *    further domain information using db_add_element_domain which defines
 *    the allowed types for elements of the set. Use db_drop_element_domain
 *    to remove entries from the set domain list.
 * returns/side-effects: error code
 * class(in) : class or instance
 * name(in)  : attribute name
 * domain(in): domain name
 *
 */
int
db_drop_set_attribute_domain (MOP class_, const char *name, int class_attribute, const char *domain)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_3ARGS_RETURN_EXPR (class_, name, domain, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_delete_set_attribute_domain (def, name, class_attribute, domain, (DB_DOMAIN *) 0);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }

  return (error);
}
コード例 #25
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_drop_method_files() - This function removes all of the currently defined
 *    method files for a class. This can be used in cases where you want to
 *    completely respecify the file list without making multiple calls to
 *    db_drop_method_file().
 * return : error code.
 * class(in): class or instance.
 */
int
db_drop_method_files (MOP class_)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_1ARG_RETURN_EXPR (class_, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_reset_method_files (def);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }

  return (error);
}
コード例 #26
0
ファイル: db_class.c プロジェクト: BogdanStroe/cubrid
/*
 * db_add_super_internal() - This function adds a super class to a class if it
 *                  did not already exist.
 * return : error code
 * class(in): class or instance
 * super(in): super class
 */
int
db_add_super_internal (MOP class_, MOP super)
{
  int error = NO_ERROR;
  SM_TEMPLATE *def;
  MOP newmop;

  CHECK_CONNECT_ERROR ();
  CHECK_MODIFICATION_ERROR ();
  CHECK_2ARGS_RETURN_EXPR (class_, super, ER_OBJ_INVALID_ARGUMENTS);

  def = smt_edit_class_mop (class_, AU_ALTER);
  if (def == NULL)
    {
      assert (er_errid () != NO_ERROR);
      error = er_errid ();
    }
  else
    {
      error = smt_add_super (def, super);
      if (error)
	{
	  smt_quit (def);
	}
      else
	{
	  error = sm_update_class_auto (def, &newmop);
	  if (error)
	    {
	      smt_quit (def);
	    }
	}
    }

  return (error);
}
コード例 #27
0
/*
 * overflow_flush_internal () -
 *   return: NO_ERROR
 *   pgptr(in):
 */
static int
overflow_flush_internal (THREAD_ENTRY * thread_p, PAGE_PTR pgptr)
{
  int ret = NO_ERROR;

  if (pgbuf_flush_with_wal (thread_p, pgptr) == NULL)
    {
      goto exit_on_error;
    }

  return ret;

exit_on_error:

  return (ret == NO_ERROR
	  && (ret = er_errid ()) == NO_ERROR) ? ER_FAILED : ret;
}
コード例 #28
0
static int
cursor_fetch_oids (CURSOR_ID * cursor_id_p, int oid_index,
		   DB_FETCH_MODE instant_fetch_mode,
		   DB_FETCH_MODE class_fetch_mode)
{
  int i;
  OID tmp_oid;
  MOBJ mobj;

  if (oid_index == 0)
    {
      /* nothing to fetch */
      return NO_ERROR;
    }

  /* form the MOP set from the existing oid_set */
  for (i = 0; i < oid_index; i++)
    {
      OR_GET_OID (&cursor_id_p->oid_set[i], &tmp_oid);
      cursor_id_p->mop_set[i] = ws_mop (&tmp_oid, (MOP) NULL);
    }


  if (oid_index == 1)
    {
      mobj = locator_fetch_object (cursor_id_p->mop_set[0],
				   instant_fetch_mode);
    }
  else
    {
      mobj = locator_fetch_set (oid_index, cursor_id_p->mop_set,
				instant_fetch_mode, class_fetch_mode, false);
    }

  if (mobj == NULL && er_errid () != ER_HEAP_UNKNOWN_OBJECT)
    {
      return ER_FAILED;
    }

  return NO_ERROR;
}
コード例 #29
0
ファイル: query_result.c プロジェクト: CUBRID/cubrid
/*
 * pt_end_query() -
 *   return:
 *   parser(in): parser context
 *   query_id_self(in):
 */
void
pt_end_query (PARSER_CONTEXT * parser, QUERY_ID query_id_self)
{
  assert (parser != NULL);
  assert (query_id_self != 0);
  assert (query_id_self == NULL_QUERY_ID || query_id_self > 0);

  if (parser->query_id > 0)
    {
      if (er_errid () != ER_LK_UNILATERALLY_ABORTED)
	{
	  qmgr_end_query (parser->query_id);
	}
    }
  else
    {
      assert (parser->query_id == 0);
    }

  parser->query_id = query_id_self;
}
コード例 #30
0
ファイル: show_meta.c プロジェクト: BogdanStroe/cubrid
static PT_NODE *
pt_check_access_status (PARSER_CONTEXT * parser, PT_NODE * node)
{
  DB_VALUE oid_val;
  MOP classop;
  PT_NODE *entity = NULL;
  PT_NODE *derived_table = NULL;
  PT_NODE *arg = NULL;

  if (!au_is_dba_group_member (Au_user))
    {
      PT_ERRORmf (parser, NULL, MSGCAT_SET_ERROR, -(ER_AU_DBA_ONLY), "show access status");
      return node;
    }

  entity = node->info.query.q.select.from;
  assert (entity != NULL);

  derived_table = entity->info.spec.derived_table;
  assert (derived_table != NULL);

  classop = sm_find_class ("db_user");
  if (classop == NULL)
    {
      assert (er_errid () != NO_ERROR);
      PT_ERRORc (parser, node, er_msg ());
      return node;
    }

  db_make_oid (&oid_val, &classop->oid_info.oid);
  arg = pt_dbval_to_value (parser, &oid_val);

  derived_table->info.showstmt.show_args = parser_append_node (arg, derived_table->info.showstmt.show_args);

  return node;
}