db_old.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.
 *
 */

/*
 * db_old.c - Obsolete API functions. New code should not use these functions.
 */

#ident "$Id$"

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <assert.h>

#include "authenticate.h"
#include "system_parameter.h"
#include "storage_common.h"
#include "db.h"
#include "class_object.h"
#include "object_print.h"
#include "server_interface.h"
#include "boot_cl.h"
#include "locator_cl.h"
#include "schema_manager.h"
#include "schema_template.h"
#include "object_accessor.h"
#include "set_object.h"
#include "virtual_object.h"
#include "parser.h"

/*
 * GENERIC LIST SUPPORT
 */

/*
 * db_list_length() - Generic list length function.  This can be used on
 *    several types of objects returned by the db_ layer.
 *    Specifically, the following types of objects are maintained in lists
 *    compatible with the generic list utilities:
 *      DB_OBJLIST
 *      DB_NAMELIST
 *      DB_ATTRIBUTE
 *      DB_METHOD
 *      DB_RESOLUTION
 *      DB_DOMAIN
 *      DB_METHFILE
 * return : length of the list, zero if empty
 * list(in): a list of some variety
 */
int
db_list_length (DB_LIST * list)
{
  /* handles NULL */
  int retval;

  retval = (ws_list_length ((DB_LIST *) list));

  return (retval);
}

/*
 *  OBJECT LIST SUPPORT
 */

/*
 * db_objlist_get() - This is a simple method for accessing the nth element of
 *    an object list.  Since these are stored as linked lists, this does a
 *    linear search to get to the requested element.
 * return : an object pointer
 * list(in): an object list
 * index(in): the object to get
 *
 * note : This isn't a good function to call if you just want to iterate over
 *    the elements. You should instead write a loop using the ->next field
 *    in the DB_OBJLIST structure.
 */
DB_OBJECT *
db_objlist_get (DB_OBJLIST * list, int index)
{
  DB_OBJLIST *el;
  MOP op;
  int i;

  op = NULL;
  for (el = list, i = 0; el != NULL && i < index; i++, el = el->next);
  if (el != NULL)
    {
      op = el->op;
    }

  return (op);
}

/*
 * db_objlist_print() - Debug function to display the contents of an object
 *    list.Prints out the internal OID's of the elements. This should ONLY be
 *    used for debugging purposes, high level users should never see the OIDs
 *    of objects.
 * return : void
 * list(in): an object list
 */
void
db_objlist_print (DB_OBJLIST * list)
{
  DB_OBJLIST *l;
  OID *oid;

  for (l = list; l != NULL; l = l->next)
    {
      oid = WS_OID (l->op);
      fprintf (stdout, "%d.%d.%d  ", oid->volid, oid->pageid, oid->slotid);
    }
  fprintf (stdout, "\n");

}

/*
 * NAMELIST SUPPORT
 */

/*
 * db_namelist_copy() - This function copies a namelist, the names in the list
 *    are copied as well as the list links.
 * return : a new list of names
 * list(in): a list of names
 *
 * note : The returned name list must be freed with db_namelist_free() function
 */
DB_NAMELIST *
db_namelist_copy (DB_NAMELIST * list)
{
  DB_NAMELIST *retval;

  CHECK_CONNECT_NULL ();

  /* handles NULL */
  retval = (nlist_copy (list));


  return (retval);
}


/*
 * db_namelist_sort() - This function is used to sort a namelist in
 *    alphabetical order.  The list is destructively sorted NOT copied
 *    so you should get rid of any pointers to the original list.
 * return : a namelist
 * names(in): an unsorted namelist
 */
DB_NAMELIST *
db_namelist_sort (DB_NAMELIST * names)
{
  DB_NAMELIST *sorted, *name, *next, *sort, *found, *prev;

  sorted = NULL;

  for (name = names, next = NULL; name != NULL; name = next)
    {
      next = name->next;
      for (sort = sorted, prev = NULL, found = NULL; sort != NULL && found == NULL; sort = sort->next)
    {
      if (strcmp (name->name, sort->name) < 0)
        {
          found = sort;
        }
      else
        {
          prev = sort;
        }
    }
      name->next = found;
      if (prev == NULL)
    {
      sorted = name;
    }
      else
    {
      prev->next = name;
    }
    }

  return (sorted);
}

/*
 * db_namelist_remove() - This function removes an element from a namelist if
 *    it matches the given name.  A pointer to the head of the list must be
 *    passed in case the element to remove is at the head.
 * return: void
 * list(in): a pointer to a pointer to a namelist
 * name(in): the name to remove
 */
void
db_namelist_remove (DB_NAMELIST ** list, const char *name)
{
  DB_NAMELIST *el;

  el = (DB_NAMELIST *) nlist_remove (list, name, NULL);
  if (el != NULL)
    {
      el->next = NULL;
      nlist_free (el);
    }

}

/*
 * db_namelist_print() - Debug function to display the names in a namelist.
 *    The list is printed to stdout.
 * return : void
 * list(in) : a namelist
 */
void
db_namelist_print (DB_NAMELIST * list)
{
  DB_NAMELIST *l;

  for (l = list; l != NULL; l = l->next)
    fprintf (stdout, "%s ", l->name);
  fprintf (stdout, "\n");

}

/*
 * OBSOLETE BROWSING FUNCTIONS
 */

/*
 * db_get_attribute_names() - This can be used to get the list of attribute
 *    names for a class.
 * return : a namelist containing attribute names
 * obj(in): a class or instance
 *
 * note : There are more general class information functions but this
 *    is a common operation so it has an optomized interface.
 */
DB_NAMELIST *
db_get_attribute_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  SM_ATTRIBUTE *att;
  SM_CLASS *class_;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (att = class_->attributes; att != NULL; att = (SM_ATTRIBUTE *) att->header.next)
    if (nlist_append (&names, att->header.name, NULL, NULL))
      {
        goto memory_error;
      }
    }
  names = db_namelist_sort (names);


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_shared_attribute_names() - This can be used to get the names of the
 *    shared attributes of a class.
 * return : a namelist of shared attribute names
 * obj(in): a class or instance
 *
 * note:   There are more general information fucntion but this
 *    is a common operation so it has an optomized interface.
 *
 */

DB_NAMELIST *
db_get_shared_attribute_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  SM_ATTRIBUTE *att;
  SM_CLASS *class_;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (att = class_->shared; att != NULL; att = (SM_ATTRIBUTE *) att->header.next)
    if (nlist_append (&names, att->header.name, NULL, NULL))
      {
        goto memory_error;
      }
    }
  names = db_namelist_sort (names);


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_class_attribute_names() - This can be used to get the list of
 *    attribute names for a class.
 * return : a namelist containing class attribute names
 * obj(in): a class or instance
 *
 * note : There are more general class information functions but this
 *    is a common operation so it has an optomized interface.
 */
DB_NAMELIST *
db_get_class_attribute_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  SM_ATTRIBUTE *att;
  SM_CLASS *class_;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (att = class_->class_attributes; att != NULL; att = (SM_ATTRIBUTE *) att->header.next)
    if (nlist_append (&names, att->header.name, NULL, NULL))
      {
        goto memory_error;
      }
    }
  names = db_namelist_sort (names);


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_ordered_attribute_names() - This is used to get a list of the
 *    instance and shared attributes in definition order.  This is useful
 *    for displaying attributes because the order makes more sense to the
 *    user than the internal storage order.
 * return : a namelist containing attribute names
 * obj(in): a class or instance
 */
DB_NAMELIST *
db_get_ordered_attribute_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  SM_ATTRIBUTE *att;
  SM_CLASS *class_;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (att = class_->ordered_attributes; att != NULL; att = att->order_link)
    if (nlist_append (&names, att->header.name, NULL, NULL))
      {
        goto memory_error;
      }
    }


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_method_names() - Returns a list of the names of the methods
 *   (not class methods) for a class.
 * return : a namelist of method names
 * obj(in): a class or instance
 */
DB_NAMELIST *
db_get_method_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  SM_METHOD *meth;
  SM_CLASS *class_;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (meth = class_->methods; meth != NULL; meth = (SM_METHOD *) meth->header.next)
    if (nlist_append (&names, meth->header.name, NULL, NULL))
      {
        goto memory_error;
      }
    }
  names = db_namelist_sort (names);


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_class_method_names() - Returns a list of the names of the class
 *    methods (not instance methods) defined for a class.
 * return : a namelist of method names
 * obj(in): a class or instance
 */
DB_NAMELIST *
db_get_class_method_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  SM_METHOD *meth;
  SM_CLASS *class_;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (meth = class_->class_methods; meth != NULL; meth = (SM_METHOD *) meth->header.next)
    if (nlist_append (&names, meth->header.name, NULL, NULL))
      {
        goto memory_error;
      }
    }
  names = db_namelist_sort (names);


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_superclass_names() - Returns a list of the names of the immediate
 *    super classes of a class.
 * return : a namelist
 * obj(in): a class or instance
 */
DB_NAMELIST *
db_get_superclass_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  DB_OBJLIST *el;
  SM_CLASS *class_;
  const char *class_name = NULL;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (el = class_->inheritance; el != NULL; el = el->next)
    {
      class_name = sm_get_ch_name (el->op);
      if (class_name == NULL)
        {
          assert (er_errid () != NO_ERROR);
          goto memory_error;
        }
      if (nlist_append (&names, class_name, NULL, NULL))
        {
          goto memory_error;
        }
    }
    }
  names = db_namelist_sort (names);


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_subclass_names() - Returns a list of the names of the immediate
 *    sub classes of a class.
 * return : a namelist
 * obj(in): a class or instance
 */
DB_NAMELIST *
db_get_subclass_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  DB_OBJLIST *el;
  SM_CLASS *class_;
  const char *class_name = NULL;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (el = class_->users; el != NULL; el = el->next)
    {
      class_name = sm_get_ch_name (el->op);
      if (class_name == NULL)
        {
          assert (er_errid () != NO_ERROR);
          goto memory_error;
        }
      if (nlist_append (&names, class_name, NULL, NULL))
        {
          goto memory_error;
        }
    }
    }
  names = db_namelist_sort (names);


  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}

/*
 * db_get_method_file_names() - Returns the list of method files defined
 *    for a class.
 * return : a namelist
 * obj(in): a class or instance
 */
DB_NAMELIST *
db_get_method_file_names (MOP obj)
{
  DB_NAMELIST *names = NULL;
  SM_METHOD_FILE *file;
  SM_CLASS *class_;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      for (file = class_->method_files; file != NULL; file = file->next)
    if (nlist_append (&names, file->name, NULL, NULL))
      {
        goto memory_error;
      }
    }
  names = db_namelist_sort (names);

  return (names);

memory_error:
  nlist_free (names);
  return NULL;
}


/*
 * db_get_method_function() - Returns the name of the C function that was
 *    defined to implement a method.
 * return : a C function name
 * obj(in): a class or instance
 * name(in): the name of a method
 */
const char *
db_get_method_function (MOP obj, const char *name)
{
  SM_CLASS *class_;
  SM_METHOD *method;
  const char *function = NULL;

  CHECK_CONNECT_NULL ();

  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      method = classobj_find_method (class_, name, 0);
      if ((method != NULL) && (method->signatures != NULL))
    {
      if (method->signatures->function_name != NULL)
        {
          function = method->signatures->function_name;
        }

    }
    }

  return (function);
}

/*
 * db_get_attribute_domain() - This is used to get a full domain descriptor
 *    for an attribute. The domain descriptor can be examined using the
 *    db_domain_ accessor functions.
 * return : the domain descriptor for an attribute
 * obj(in): a class or instance
 * name(in): attribute name
 */
DB_DOMAIN *
db_get_attribute_domain (MOP obj, const char *name)
{
  SM_CLASS *class_;
  SM_ATTRIBUTE *att;
  SM_DOMAIN *domain;

  CHECK_CONNECT_NULL ();

  domain = NULL;
  att = NULL;
  if (au_fetch_class (obj, &class_, AU_FETCH_READ, AU_SELECT) == NO_ERROR)
    {
      att = classobj_find_attribute (class_, name, 0);
      if (att != NULL)
    {
      domain = att->domain;
      sm_filter_domain (domain, NULL);
    }
    }


  return ((DB_DOMAIN *) domain);
}

/*
 * db_get_attribute_type() - Returns the internal basic type identifier for
 *    an attribute.
 * return : type identifier constant
 * obj(in): class or instance
 * name(in): attribute name
 */
DB_TYPE
db_get_attribute_type (MOP obj, const char *name)
{
  DB_TYPE type = DB_TYPE_NULL;

  CHECK_CONNECT_ZERO_TYPE (DB_TYPE);

  if (obj != NULL && name != NULL)
    {
      type = sm_att_type_id (obj, name);
    }
  else
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OBJ_INVALID_ARGUMENTS, 0);
    }

  return (type);
}

/*
 * db_get_attribute_class() - This returns the MOP of the class that was
 *    defined as the domain of this attribute.  The basic type of the
 *    attribute must be DB_TYPE_OBJECT, if not, this function will return
 *    NULL.
 * return : a class pointer
 * obj(in): class or instance
 * name(in): attribute name
 */
DB_OBJECT *
db_get_attribute_class (MOP obj, const char *name)
{
  MOP class_ = NULL;

  CHECK_CONNECT_NULL ();

  if (obj != NULL && name != NULL)
    {
      class_ = sm_att_class (obj, name);
    }
  else
    {
      er_set (ER_ERROR_SEVERITY, ARG_FILE_LINE, ER_OBJ_INVALID_ARGUMENTS, 0);
    }

  return (class_);
}

/*
 * db_is_indexed() - This function is used to see if an attribute has an index
 *    or not.
 * return : non-zero if attribute is indexed
 * classmp(in): class pointer
 * attname(in): attribute name
 *
 * note : Because this returns a true or false, it masks any errors that may
 *    have been encountered aint the way so callers should first make sure that
 *    the class is accessible, the attribute exists, etc.
 */
int
db_is_indexed (MOP classmop, const char *attname)
{
  int retval;
  BTID btid;

  CHECK_CONNECT_FALSE ();
  CHECK_2ARGS_ZERO (classmop, attname);

  retval = ((sm_get_index (classmop, attname, &btid) == NO_ERROR) ? true : false);

  return (retval);
}

/*
 * db_print_mop() - This can be used to get a printable representation of
 *    an object pointer. This should be used only for debugging purposes
 *    or other special system utilities.
 * return : number of chars used in the printed representation
 * obj(in): class or instance pointer
 * buffer(out): buffer to contain the printed representation
 * maxlen(in): the maximum number of characters in the buffer
 *
 * note : Since this prints the internal object identifier numbers, great
 *    care must be taken that these numbers don't surface to "users" because
 *    there should be no assumed knowledge of these numbers.  They may
 *    change at any time due to database re-configuration.
 */
int
db_print_mop (DB_OBJECT * obj, char *buffer, int maxlen)
{
  int retval;

  CHECK_CONNECT_ZERO ();
  CHECK_2ARGS_ZERO (obj, buffer);

  /* handles NULL */
  retval = (help_describe_mop (obj, buffer, maxlen));

  return (retval);
}

/*
 * db_get_method_source_file() - This is an experimental function for the
 *    initial browser. It isn't guaranteed to work in all cases. It will
 *    attempt to locate the .c file that contains the source for a method
 *    implementation.
 * return : C string
 * class(in): class or instance
 * method(in): method name
 *
 * note : There isn't any way that this can be determined for certain, what it
 *    does now is find the .o file that contains the implementation function
 *    and assume that a .c file exists in the same directory that contains
 *    the source.
 */
char *
db_get_method_source_file (MOP obj, const char *name)
{
  char *retval;

  CHECK_CONNECT_NULL ();
  CHECK_2ARGS_NULL (obj, name);

  retval = (sm_get_method_source_file (obj, name));

  return (retval);
}