wreadandwritegeometry.cpp

ReadAndWriteOracleSpatial C++读写OracleSpatial

**              NULL x, y and z fields.
**
*******************************************************************************/
void
WReadAndWriteGeometry::sc_ops_get_sdo_point (void)

{
  double x, y, z;

  if (m_geom_ind->sdo_point._atomic == OCI_IND_NOTNULL)
  {
    if (m_geom_ind->sdo_point.x == OCI_IND_NOTNULL)
    {
      checkerr(errhp, OCINumberToReal(errhp, &(m_geom_obj->sdo_point.x), 
                                     (uword)sizeof(double),
          (dvoid *)&x));

        printf("-- sdo_point.X: %.9lf \n", x);
    }

    if (m_geom_ind->sdo_point.y == OCI_IND_NOTNULL)
    {
      checkerr(errhp, OCINumberToReal(errhp, &(m_geom_obj->sdo_point.y), 
                                     (uword)sizeof(double),
          (dvoid *)&y));

      printf("-- sdo_point.Y: %.9lf \n", y);
    }

    if (m_geom_ind->sdo_point.z == OCI_IND_NOTNULL)
    {
      checkerr(errhp, OCINumberToReal(errhp, &(m_geom_obj->sdo_point.z), 
                                     (uword)sizeof(double),
          (dvoid *)&z));

      printf("-- sdo_point.Z: %.9lf \n", z);
    }
  }
  else
    printf ("-- sdo_point IS NULL\n");
}


/*******************************************************************************
**
** Routine:     sc_ops_next_elem
**
** Description: Go to the next element in this geometry. 
**              Returns 1 if there are more elements.
**              Returns 0 if there are no more elements.
**
*******************************************************************************/
int
WReadAndWriteGeometry::sc_ops_next_elem (void)

{
  int more_elems = 1;

  if (global_first_elem)
    global_first_elem = 0;
  else
    global_elem_index = global_elem_index + 3;

  return global_elem_index < global_nelems;
}

/*******************************************************************************
**
** Routine:     sc_ops_get_element_type
**
** Description: Prints the element_type for current element.
**
*******************************************************************************/
ub4
WReadAndWriteGeometry::sc_ops_get_element_type ()

{
  boolean        exists;
  OCINumber      *oci_number;
  ub4            element_type;

  checkerr(errhp, OCICollGetElem(envhp, errhp, 
                                 (OCIColl *)(m_geom_obj->sdo_elem_info), 
            (sb4)(global_elem_index + 1), 
                                 (boolean *)&exists, 
            (dvoid **)&oci_number, (dvoid **)0));
  checkerr(errhp, OCINumberToInt(errhp, oci_number, 
     (uword)sizeof(ub4), OCI_NUMBER_UNSIGNED,
     (dvoid *)&element_type));

  printf("-- element type: %u \n", element_type); 
  fflush (stdout);

  return element_type;
}


/*******************************************************************************
**
** Routine:     get_interpretation
**
** Description: Prints the interpretation field for current element.
**
*******************************************************************************/
ub4
WReadAndWriteGeometry::get_interpretation (void)

{
  boolean        exists;
  OCINumber      *oci_number;
  ub4            interpretation;

  checkerr(errhp, OCICollGetElem(envhp, errhp, 
                                 (OCIColl *)(m_geom_obj->sdo_elem_info), 
            (sb4)(global_elem_index + 2), 
                                 (boolean *)&exists, 
            (dvoid **)&oci_number, (dvoid **)0));

  checkerr(errhp, OCINumberToInt(errhp, oci_number, 
     (uword)sizeof(ub4), OCI_NUMBER_UNSIGNED,
     (dvoid *)&interpretation));

  printf("-- interpretation: %u \n", interpretation); 
  fflush(stdout);

  return interpretation;
}


/*******************************************************************************
**
** Routine:     get_ordinates
**
** Description: Prints ordinates out of the ordinates array.
**
*******************************************************************************/
void 
WReadAndWriteGeometry::get_ordinates (int starting_offset, int ending_offset)

{
  int col;
  boolean        exists;
  OCINumber      *oci_number;
  double         double_val;

  /* 
  ** Get ordinates for the current element.
  */
  for (col = starting_offset; col <= ending_offset; col++)
  {
    checkerr(errhp, OCICollGetElem(envhp, errhp, 
       (OCIColl *)(m_geom_obj->sdo_ordinates), 
       (sb4)col, (boolean *)&exists, 
       (dvoid **)&oci_number, (dvoid **)0));
    checkerr(errhp, OCINumberToReal(errhp, oci_number, (uword)sizeof(double),
     (dvoid *)&double_val));
 
    if ((col % global_num_dimensions) == 0)
      printf("%.9lf", double_val);
    else
      printf(", %.9lf", double_val);

    if ((col % global_num_dimensions) == (global_num_dimensions - 1))
      printf("\n");
  } /* end for */

  printf("\n");
}


/*******************************************************************************
**
** Routine:     get_next_ending_offset
**
** Description: Returns the ending offset of current element.
**
*******************************************************************************/
int
WReadAndWriteGeometry::get_next_ending_offset (int processing_type_4or5)

{
  boolean        exists;
  OCINumber      *oci_number;
  int            ending_offset;

  /* last element? */
  if (global_elem_index == global_nelems - 3)
    ending_offset = global_nords;
  else
  {
    checkerr(errhp, OCICollGetElem(envhp, errhp, 
              (OCIColl *)(m_geom_obj->sdo_elem_info), 
              (sb4)(global_elem_index + 3), 
                                   (boolean *)&exists, 
              (dvoid **)&oci_number, (dvoid **)0));
    checkerr(errhp, OCINumberToInt(errhp, 
              oci_number, 
              (uword)sizeof(int), OCI_NUMBER_SIGNED,
              (dvoid *)&ending_offset));

    if (processing_type_4or5)
    {
      /* Add 1 to next elements starting offset */
      ending_offset++;
    }
    else
    {
      /* Subtract 1 from next elements starting offset */
      ending_offset--;
    }
  }

  /* shift offsets from 1..n to 0..n-1 */
  ending_offset--;

  printf("-- ending offset: %d \n", ending_offset+1);

  return ending_offset;
}

/*******************************************************************************
**
** Routine:     get_next_starting_offset
**
** Description: Returns the starting offset of the current element.
**
*******************************************************************************/
int
WReadAndWriteGeometry::get_next_starting_offset (int read_varray)

{
  boolean        exists;
  OCINumber      *oci_number;
  int            starting_offset;


  /* get the element info structure */
  if (read_varray)
  {
    /* This is the first element, get the starting offset */
    checkerr(errhp, OCICollGetElem(envhp, errhp, 
              (OCIColl *)(m_geom_obj->sdo_elem_info), 
              (sb4)(global_elem_index), (boolean *)&exists,
              (dvoid **)&oci_number, (dvoid **)0));

    /* get starting and ending offsets in ordinate array */
    checkerr(errhp, OCINumberToInt(errhp, oci_number, 
       (uword)sizeof(ub4), OCI_NUMBER_SIGNED,
       (dvoid *)&starting_offset));

    /* shift offsets from 1..n to 0..n-1 */
    starting_offset--;
  }
  else
    starting_offset = global_ending_offset + 1;
      
  printf("-- starting offset: %d \n", starting_offset+1);

  return starting_offset;
}


/*******************************************************************************
**
** Routine:     sc_ops_get_type1
**
** Description: Print the ordinates for a type1 element.
**
*******************************************************************************/
void
WReadAndWriteGeometry::sc_ops_get_type1 (void)

{
   int i,
       interp,
       start,
       end;

   start = get_next_starting_offset (global_ending_offset == -1);
   end = get_next_ending_offset (0); 
   interp = get_interpretation ();

   for (i = 0; i < interp; i++)
   {
     get_ordinates (start, 
                    start + global_num_dimensions - 1);
     start = start + global_num_dimensions;
   }
}


/*******************************************************************************
**
** Routine:     sc_ops_get_type2
**
** Description: Print the ordinates for a type2 element.
**
*******************************************************************************/
void
WReadAndWriteGeometry::sc_ops_get_type2 (void)

{
   int interp = get_interpretation ();

   get_ordinates (get_next_starting_offset(global_ending_offset == -1), 
                  get_next_ending_offset (0));
}

/*******************************************************************************
**
** Routine:     sc_ops_get_type3
**
** Description: Print the ordinates for a type3 element.
**
*******************************************************************************/
void
WReadAndWriteGeometry::sc_ops_get_type3 (void)

{
   int interp = get_interpretation (),
       start  = get_next_starting_offset(global_ending_offset == -1),
       end    = get_next_ending_offset(0);

   if (interp == 3) /* Rectangle, 2 po;ints */
     get_ordinates (start,
                    start + global_num_dimensions * 2 - 1);

   else if (interp == 4) /* Circle, 3 points */
     get_ordinates (start,
                    start + global_num_dimensions * 3 - 1);

   else if (interp == 1 || interp == 2) /* interpretation 1 or 2 */
     get_ordinates (start, end);
}


/*******************************************************************************
**
** Routine:     sc_ops_get_type4
**
** Description: Print the ordinates for a type4 element.
**
*******************************************************************************/
void
WReadAndWriteGeometry::sc_ops_get_type4 (void)

{
  int interp = get_interpretation (),
      start,
      end,
      i;

  for (i = 0; i < interp; i++)
  {
     global_elem_index = global_elem_index + 3;
     start  = get_next_starting_offset(-1);
 
     if (i == interp - 1)
       end = get_next_ending_offset(0);
     else
       end = get_next_ending_offset(1);

     get_ordinates (start, end);
  }
}


/*******************************************************************************
**
** Routine:     sc_ops_get_type5
**
** Description: Print the ordinates for a type5 element.
**
*******************************************************************************/
void
WReadAndWriteGeometry::sc_ops_get_type5 (void)

{
  int interp = get_interpretation (),
      start,
      end,
      i;

  for (i = 0; i < interp; i++)
  {
     global_elem_index = global_elem_index + 3;
     start  = get_next_starting_offset(-1);
 
     if (i == interp - 1)
       end = get_next_ending_offset(0);
     else
       end = get_next_ending_offset(1);

     get_ordinates (start, end);
  }
}


/*******************************************************************************
**
** Routine:     write_geometries
**
** Description: 
**
*******************************************************************************/
void WReadAndWriteGeometry::write_geometries ()
{
 int i;
 int starting_offset = 1;
 int element_type = 2;
 int interpretation = 1;
 OCINumber oci_number;
 OCIBind *bnd1p = NULL, *bnd2p = NULL;
 char query[500];

 for (i = 0; i < 1002; i++)
 {
  checkerr(errhp, OCINumberFromReal(errhp, (dvoid *)&(test_ordinates[i]), 
      (uword)sizeof(double),&oci_number));

  checkerr(errhp, OCICollAppend(envhp, errhp, 
      (dvoid *) &oci_number,
      (dvoid *)0, (OCIColl *)ordinates));
 }

 checkerr(errhp, OCINumberFromInt(errhp, (dvoid *)&starting_offset, 
     (uword)sizeof(ub4), OCI_NUMBER_UNSIGNED, 
     &oci_number));
 checkerr(errhp, OCICollAppend(envhp, errhp, (dvoid *)&oci_number,
     (dvoid *)0, (OCIColl *)elem_info));

 checkerr(errhp, OCINumberFromInt(errhp, (dvoid *)&element_type, 
     (uword)sizeof(ub4), OCI_NUMBER_UNSIGNED, 
     &oci_number));
 checkerr(errhp, OCICollAppend(envhp, errhp, (dvoid *)&oci_number,
     (dvoid *)0, (OCIColl *)elem_info));

 checkerr(errhp, OCINumberFromInt(errhp, (dvoid *)&interpretation, 
     (uword)sizeof(ub4), OCI_NUMBER_UNSIGNED, 
     &oci_number));
 checkerr(errhp, OCICollAppend(envhp, errhp, (dvoid *)&oci_number,
     (dvoid *)0, (OCIColl *)elem_info));

 sprintf(query, "INSERT INTO %s (gid, %s) "
     "VALUES (1, %s(4, NULL, NULL, :elem_info, :ordinates))", 
     "test_insert", "geometry", SDO_GEOMETRY);

 checkerr(errhp, OCIStmtPrepare(stmthp, errhp, 
     (text *)query, (ub4)strlen(query), 
     (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT));


 /* bind info_obj varray object */
 checkerr(errhp, OCIBindByName(stmthp, &bnd1p, errhp, 
     (text *)":elem_info", (sb4)-1, (dvoid *)0, 
     (sb4)0, SQLT_NTY, (dvoid *)0, (ub2 *)0, 
     (ub2 *)0, (ub4)0, (ub4 *)0, 
     (ub4)OCI_DEFAULT));
 checkerr(errhp, OCIBindObject(bnd1p, errhp, elem_info_tdo, 
     (dvoid **)&elem_info, (ub4 *)0, 
     (dvoid **)0, (ub4 *)0));
 /* bind coordinate varray object */
 checkerr(errhp, OCIBindByName(stmthp, &bnd2p, errhp, 
     (text *)":ordinates", (sb4)-1, (dvoid *)0, 
     (sb4)0, SQLT_NTY, (dvoid *)0, (ub2 *)0, 
     (ub2 *)0, (ub4)0, (ub4 *)0, 
     (ub4)OCI_DEFAULT));
 checkerr(errhp, OCIBindObject(bnd2p, errhp, ordinates_tdo, 
     (dvoid **)&ordinates, (ub4 *)0, 
     (dvoid **)0, (ub4 *)0));

 checkerr(errhp, OCIStmtExecute(svchp, stmthp, errhp, (ub4)1, (ub4)0, 
     (OCISnapshot *)NULL, (OCISnapshot *)NULL, 
     (ub4)OCI_DEFAULT));
}