else
  as_fn_error $? "cannot find librttopo.h, bailing out" "$LINENO" 5
fi

done

	  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing rtgeom_make_valid" >&5
$as_echo_n "checking for library containing rtgeom_make_valid... " >&6; }
if ${ac_cv_search_rtgeom_make_valid+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char rtgeom_make_valid ();
int
main ()
{
return rtgeom_make_valid ();
  ;
  return 0;
}
_ACEOF
for ac_lib in '' rttopo; do
  if test -z "$ac_lib"; then
    ac_res="none required"
  else
    ac_res=-l$ac_lib
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
  fi
  if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_search_rtgeom_make_valid=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext
  if ${ac_cv_search_rtgeom_make_valid+:} false; then :
  break
fi
done
if ${ac_cv_search_rtgeom_make_valid+:} false; then :

else
  ac_cv_search_rtgeom_make_valid=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_rtgeom_make_valid" >&5
$as_echo "$ac_cv_search_rtgeom_make_valid" >&6; }
ac_res=$ac_cv_search_rtgeom_make_valid
if test "$ac_res" != no; then :
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"

else
  as_fn_error $? "'librttopo' is required but it doesn't seem to be installed on this system. You may need to try re-running configure with a --disable-rttopo parameter." "$LINENO" 5
fi

	  $as_echo "#define ENABLE_RTTOPO 1" >>confdefs.h

  fi
else
  $as_echo "#define OMIT_GEOS 1" >>confdefs.h

else
  as_fn_error $? "cannot find librttopo.h, bailing out" "$LINENO" 5
fi

done

	  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing rtt_AddLineNoFace" >&5
$as_echo_n "checking for library containing rtt_AddLineNoFace... " >&6; }
if ${ac_cv_search_rtt_AddLineNoFace+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_func_search_save_LIBS=$LIBS
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char rtt_AddLineNoFace ();
int
main ()
{
return rtt_AddLineNoFace ();
  ;
  return 0;
}
_ACEOF
for ac_lib in '' rttopo; do
  if test -z "$ac_lib"; then
    ac_res="none required"
  else
    ac_res=-l$ac_lib
    LIBS="-l$ac_lib  $ac_func_search_save_LIBS"
  fi
  if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_search_rtt_AddLineNoFace=$ac_res
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext
  if ${ac_cv_search_rtt_AddLineNoFace+:} false; then :
  break
fi
done
if ${ac_cv_search_rtt_AddLineNoFace+:} false; then :

else
  ac_cv_search_rtt_AddLineNoFace=no
fi
rm conftest.$ac_ext
LIBS=$ac_func_search_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_rtt_AddLineNoFace" >&5
$as_echo "$ac_cv_search_rtt_AddLineNoFace" >&6; }
ac_res=$ac_cv_search_rtt_AddLineNoFace
if test "$ac_res" != no; then :
  test "$ac_res" = "none required" || LIBS="$ac_res $LIBS"

else
  as_fn_error $? "'librttopo' (>= v.1.1.0) is required but it doesn't seem to be installed on this system. You may need to try re-running configure with a --disable-rttopo parameter." "$LINENO" 5
fi

	  $as_echo "#define ENABLE_RTTOPO 1" >>confdefs.h

  fi
else
  $as_echo "#define OMIT_GEOS 1" >>confdefs.h

  #   --enable-rttopo
  #
  AC_ARG_ENABLE(rttopo, [AS_HELP_STRING(
	  [--enable-rttopo], [enables RTTOPO support [default=no]])],
	  [], [enable_rttopo=no])
  if test x"$enable_rttopo" != "xno"; then
	  AC_CHECK_HEADERS(librttopo.h,, [AC_MSG_ERROR([cannot find librttopo.h, bailing out])])
	  AC_SEARCH_LIBS(rtgeom_make_valid,rttopo,,AC_MSG_ERROR(['librttopo' is required but it doesn't seem to be installed on this system. You may need to try re-running configure with a --disable-rttopo parameter.]))
	  AC_DEFINE(ENABLE_RTTOPO)
  fi
else
  AC_DEFINE(OMIT_GEOS)
fi

#-----------------------------------------------------------------------

  #   --enable-rttopo
  #
  AC_ARG_ENABLE(rttopo, [AS_HELP_STRING(
	  [--enable-rttopo], [enables RTTOPO support [default=no]])],
	  [], [enable_rttopo=no])
  if test x"$enable_rttopo" != "xno"; then
	  AC_CHECK_HEADERS(librttopo.h,, [AC_MSG_ERROR([cannot find librttopo.h, bailing out])])
	  AC_SEARCH_LIBS(rtt_AddLineNoFace,rttopo,,AC_MSG_ERROR(['librttopo' (>= v.1.1.0) is required but it doesn't seem to be installed on this system. You may need to try re-running configure with a --disable-rttopo parameter.]))
	  AC_DEFINE(ENABLE_RTTOPO)
  fi
else
  AC_DEFINE(OMIT_GEOS)
fi

#-----------------------------------------------------------------------

	  gaia = NULL;
	  break;
      };

    return gaia;
}

static gaiaGeomCollPtr
fromRTGeom (const RTCTX * ctx, const RTGEOM * rtgeom, const int dimension_model,
	    const int declared_type)
{
/* converting a RTGEOM Geometry into a GAIA Geometry */
    gaiaGeomCollPtr gaia = NULL;



    if (rtgeom == NULL)
	return NULL;
    if (rtgeom_is_empty (ctx, rtgeom))
	return NULL;

    if (dimension_model == GAIA_XY_Z)

	  gaia = NULL;
	  break;
      };

    return gaia;
}

SPATIALITE_PRIVATE void *
fromRTGeom (const void * pctx, const void * prtgeom, const int dimension_model,
	    const int declared_type)
{
/* converting a RTGEOM Geometry into a GAIA Geometry */
    gaiaGeomCollPtr gaia = NULL;
    const RTCTX * ctx = (const RTCTX *)pctx;
    const RTGEOM * rtgeom = (const RTGEOM *)prtgeom;

    if (rtgeom == NULL)
	return NULL;
    if (rtgeom_is_empty (ctx, rtgeom))
	return NULL;

    if (dimension_model == GAIA_XY_Z)

 \sa gaiaTopologyFromDBMS
 */
    GAIATOPO_DECLARE sqlite3_int64
	gaiaTopoGeo_AddPoint (GaiaTopologyAccessorPtr ptr, gaiaPointPtr pt,
			      double tolerance);




















/**
 Adds a Linestring to an existing Topology and possibly splitting Edges/Faces.

 \param ptr pointer to the Topology Accessor Object.
 \param ln pointer to the Linestring Geometry.
 \param tolerance approximation factor.
 \param edge_ids on success will point to an array of Edge IDs
 \param ids_count on success will report the number of Edge IDs in the
 above array

 \return 1 on success; 0 on failure.

 \sa gaiaTopologyFromDBMS
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_AddLineString (GaiaTopologyAccessorPtr ptr,
				   gaiaLinestringPtr pt, double tolerance,
				   sqlite3_int64 ** edge_ids, int *ids_count);
































/**
 Adds a Polygon to an existing Topology and possibly splitting Edges/Faces.

 \param ptr pointer to the Topology Accessor Object.
 \param pg pointer to the Polygon Geometry.
 \param tolerance approximation factor.
 \param face_ids on success will point to an array of Face IDs
................................................................................
 and/or Polygon Rings will be split into simpler Lines having a length
 not exceeding this threshold. If both line_max_points and max_legth
 are set as the same time the first condition occurring will cause
 a new Line to be started. 

 \return 1 on success; -1 on failure (will raise an exception).

 \sa gaiaTopologyFromDBMS
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_FromGeoTable (GaiaTopologyAccessorPtr ptr,
				  const char *db_prefix, const char *table,
				  const char *column, double tolerance,
				  int line_max_points, double max_length);































/**
 Populates a Topology by importing a whole GeoTable - Extended mode

 \param ptr pointer to the Topology Accessor Object.
 \param sql_in an SQL statement (SELECT) returning input features
 \param sql_out a second SQL statement (INSERT INTO) intended to
 store failing features references into the "dustbin" table.
................................................................................
 a new Line to be started. 

 \return 0 if all input features were succesfully importer, or a
 positive number (total count of failing features raising an exception
 and referenced by the "dustbin" table); -1 if some unexpected
 error occurred.

 \sa gaiaTopologyFromDBMS
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_FromGeoTableExtended (GaiaTopologyAccessorPtr ptr,
					  const char *sql_in,




































					  const char *sql_out,
					  const char *sql_in2, double tolerance,
					  int line_max_points,
					  double max_length);

/**
 Creates a temporary table containing a validation report for a given TopoGeo.

 \sa gaiaTopologyFromDBMS
 */
    GAIATOPO_DECLARE sqlite3_int64
	gaiaTopoGeo_AddPoint (GaiaTopologyAccessorPtr ptr, gaiaPointPtr pt,
			      double tolerance);

/**
 Adds a Linestring to an existing Topology without determining generated faces..

 \param ptr pointer to the Topology Accessor Object.
 \param ln pointer to the Linestring Geometry.
 \param tolerance approximation factor.
 \param edge_ids on success will point to an array of Edge IDs
 \param ids_count on success will report the number of Edge IDs in the
 above array

 \return 1 on success; 0 on failure.

 \sa gaiaTopologyFromDBMS, gaiaTopoGeo_AddLineStringNoFace
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_AddLineString (GaiaTopologyAccessorPtr ptr,
				   gaiaLinestringPtr pt, double tolerance,
				   sqlite3_int64 ** edge_ids, int *ids_count);

/**
 Adds a Linestring to an existing Topology and possibly splitting Edges/Faces.

 \param ptr pointer to the Topology Accessor Object.
 \param ln pointer to the Linestring Geometry.
 \param tolerance approximation factor.
 \param edge_ids on success will point to an array of Edge IDs
 \param ids_count on success will report the number of Edge IDs in the
 above array

 \return 1 on success; 0 on failure.

 \sa gaiaTopologyFromDBMS, gaiaTopoGeo_AddLineString, gaiaTopoGeo_Polygonize
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_AddLineStringNoFace (GaiaTopologyAccessorPtr ptr,
				   gaiaLinestringPtr pt, double tolerance,
				   sqlite3_int64 ** edge_ids, int *ids_count);

/**
 Determine and register all topology faces.

 \param ptr pointer to the Topology Accessor Object.

 \return 1 on success; 0 on failure.

 \sa gaiaTopologyFromDBMS, gaiaTopoGeo_AddLineStringNoFace, 
 gaiaTopoGeo_FromGeoTableNoFace, FromGeoTableNoFaceExt
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_Polygonize (GaiaTopologyAccessorPtr ptr);

/**
 Snap Geometry to Topology.

 \param ptr pointer to the Topology Accessor Object.
 \param geom pointer to the input Geometry.
 \param tolerance approximation factor.
 \param iterate if non zero, allows snapping to more than a single 
 vertex, iteratively
 \param remove_vertices if non zero, makes an initial pass removing
 vertices within tolerance

 \return pointer to the snapped Geometry; NULL on failure.

 \sa gaiaTopologyFromDBMS
 */
    GAIATOPO_DECLARE gaiaGeomCollPtr
	gaiaTopoSnap (GaiaTopologyAccessorPtr ptr, gaiaGeomCollPtr geom, double tolerance, int iterate, int remove_vertices);

/**
 Adds a Polygon to an existing Topology and possibly splitting Edges/Faces.

 \param ptr pointer to the Topology Accessor Object.
 \param pg pointer to the Polygon Geometry.
 \param tolerance approximation factor.
 \param face_ids on success will point to an array of Face IDs
................................................................................
 and/or Polygon Rings will be split into simpler Lines having a length
 not exceeding this threshold. If both line_max_points and max_legth
 are set as the same time the first condition occurring will cause
 a new Line to be started. 

 \return 1 on success; -1 on failure (will raise an exception).

 \sa gaiaTopologyFromDBMS, gaiaTopoGeo_FromGeoTableNoFace
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_FromGeoTable (GaiaTopologyAccessorPtr ptr,
				  const char *db_prefix, const char *table,
				  const char *column, double tolerance,
				  int line_max_points, double max_length);

/**
 Populates a Topology by importing a whole GeoTable without 
 determining generated faces

 \param ptr pointer to the Topology Accessor Object.
 \param db-prefix prefix of the DB containing the input GeoTable.
 If NULL the "main" DB will be intended by default.
 \param table name of the input GeoTable.
 \param column name of the input Geometry Column.
 Could be NULL is the input table has just a single Geometry Column.
 \param tolerance approximation factor.
 \param line_max_points if set to a positive number all input Linestrings
 and/or Polygon Rings will be split into simpler Linestrings having no more 
 than this maximum number of points. 
 \param max_length if set to a positive value all input Linestrings 
 and/or Polygon Rings will be split into simpler Lines having a length
 not exceeding this threshold. If both line_max_points and max_legth
 are set as the same time the first condition occurring will cause
 a new Line to be started. 

 \return 1 on success; -1 on failure (will raise an exception).

 \sa gaiaTopologyFromDBMS, gaiaTopoGeo_FromGeoTable, gaiaTopoGeo_Polygonize
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_FromGeoTableNoFace (GaiaTopologyAccessorPtr ptr,
				  const char *db_prefix, const char *table,
				  const char *column, double tolerance,
				  int line_max_points, double max_length);

/**
 Populates a Topology by importing a whole GeoTable - Extended mode

 \param ptr pointer to the Topology Accessor Object.
 \param sql_in an SQL statement (SELECT) returning input features
 \param sql_out a second SQL statement (INSERT INTO) intended to
 store failing features references into the "dustbin" table.
................................................................................
 a new Line to be started. 

 \return 0 if all input features were succesfully importer, or a
 positive number (total count of failing features raising an exception
 and referenced by the "dustbin" table); -1 if some unexpected
 error occurred.

 \sa gaiaTopologyFromDBMS, gaiaTopoGeo_FromGeoTableNoFaceExtended
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_FromGeoTableExtended (GaiaTopologyAccessorPtr ptr,
					  const char *sql_in,
					  const char *sql_out,
					  const char *sql_in2, double tolerance,
					  int line_max_points,
					  double max_length);

/**
 Populates a Topology by importing a whole GeoTable without 
 determining generated faces - Extended mode

 \param ptr pointer to the Topology Accessor Object.
 \param sql_in an SQL statement (SELECT) returning input features
 \param sql_out a second SQL statement (INSERT INTO) intended to
 store failing features references into the "dustbin" table.
 \param sql_in2 an SQL statement (SELECT) returning a single input 
 feature (used for retrying to insert a failing feature)
 \param tolerance approximation factor.
 \param line_max_points if set to a positive number all input Linestrings
 and/or Polygon Rings will be split into simpler Linestrings having no more 
 than this maximum number of points. 
 \param max_length if set to a positive value all input Linestrings 
 and/or Polygon Rings will be split into simpler Lines having a length
 not exceeding this threshold. If both line_max_points and max_legth
 are set as the same time the first condition occurring will cause
 a new Line to be started. 

 \return 0 if all input features were succesfully importer, or a
 positive number (total count of failing features raising an exception
 and referenced by the "dustbin" table); -1 if some unexpected
 error occurred.

 \sa gaiaTopologyFromDBMS, gaiaTopoGeo_FromGeoTableExtended, 
 gaiaTopoGeo_Polygonize
 */
    GAIATOPO_DECLARE int
	gaiaTopoGeo_FromGeoTableNoFaceExtended (GaiaTopologyAccessorPtr ptr,
					  const char *sql_in,
					  const char *sql_out,
					  const char *sql_in2, double tolerance,
					  int line_max_points,
					  double max_length);

/**
 Creates a temporary table containing a validation report for a given TopoGeo.

    SPATIALITE_PRIVATE int gaiaAuxClonerExecute (const void *cloner);

    SPATIALITE_PRIVATE int gaia_matrix_to_arrays (const unsigned char *blob,
						  int blob_sz, double *E,
						  double *N, double *Z);

/* Topology SQL functions */


    SPATIALITE_PRIVATE void fnctaux_GetLastTopologyException (const void
							      *context,
							      int argc,
							      const void *argv);

    SPATIALITE_PRIVATE void fnctaux_CreateTopology (const void *context,
						    int argc, const void *argv);
................................................................................
    SPATIALITE_PRIVATE void fnctaux_TopoGeo_AddPoint (const void *context,
						      int argc,
						      const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_AddLineString (const void *context,
							   int argc,
							   const void *argv);









    SPATIALITE_PRIVATE void fnctaux_TopoGeo_FromGeoTable (const void *context,
							  int argc,
							  const void *argv);





    SPATIALITE_PRIVATE void fnctaux_TopoGeo_FromGeoTableExt (const void
							     *context, int argc,
							     const void *argv);













    SPATIALITE_PRIVATE void fnctaux_TopoGeo_ToGeoTable (const void *context,
							int argc,
							const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_ToGeoTableGeneralize (const void
								  *context,

    SPATIALITE_PRIVATE int gaiaAuxClonerExecute (const void *cloner);

    SPATIALITE_PRIVATE int gaia_matrix_to_arrays (const unsigned char *blob,
						  int blob_sz, double *E,
						  double *N, double *Z);

/* Topology SQL functions */
	SPATIALITE_PRIVATE void * fromRTGeom (const void * ctx, const void * rtgeom, const int dimension_model, const int declared_type);
	
    SPATIALITE_PRIVATE void fnctaux_GetLastTopologyException (const void
							      *context,
							      int argc,
							      const void *argv);

    SPATIALITE_PRIVATE void fnctaux_CreateTopology (const void *context,
						    int argc, const void *argv);
................................................................................
    SPATIALITE_PRIVATE void fnctaux_TopoGeo_AddPoint (const void *context,
						      int argc,
						      const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_AddLineString (const void *context,
							   int argc,
							   const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_AddLineStringNoFace (const void *context,
							   int argc,
							   const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_Polygonize (const void *context,
							   int argc,
							   const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_FromGeoTable (const void *context,
							  int argc,
							  const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_FromGeoTableNoFace (const void *context,
							  int argc,
							  const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_FromGeoTableExt (const void
							     *context, int argc,
							     const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_FromGeoTableNoFaceExt (const void
							     *context, int argc,
							     const void *argv);

    SPATIALITE_PRIVATE void fnctaux_Polygonize (const void
							     *context, int argc,
							     const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoSnap (const void
							     *context, int argc,
							     const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_ToGeoTable (const void *context,
							int argc,
							const void *argv);

    SPATIALITE_PRIVATE void fnctaux_TopoGeo_ToGeoTableGeneralize (const void
								  *context,

static void
fnct_TopoGeo_AddLineString (sqlite3_context * context, int argc,
			    sqlite3_value ** argv)
{
    fnctaux_TopoGeo_AddLineString (context, argc, argv);
}








static void
fnct_TopoGeo_FromGeoTable (sqlite3_context * context, int argc,
			   sqlite3_value ** argv)
{
    fnctaux_TopoGeo_FromGeoTable (context, argc, argv);
}








static void
fnct_TopoGeo_FromGeoTableExt (sqlite3_context * context, int argc,
			      sqlite3_value ** argv)
{
    fnctaux_TopoGeo_FromGeoTableExt (context, argc, argv);
}






















static void
fnct_TopoGeo_ToGeoTable (sqlite3_context * context, int argc,
			 sqlite3_value ** argv)
{
    fnctaux_TopoGeo_ToGeoTable (context, argc, argv);
}
................................................................................
				      fnct_GetFaceByPoint, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_AddPoint", 3,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_AddPoint, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_AddLineString", 3,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_AddLineString, 0, 0, 0);



	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTable", 5,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTable, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTable", 7,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTable, 0, 0, 0);






	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableExt", 7,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableExt, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableExt", 9,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableExt, 0, 0, 0);












	  sqlite3_create_function_v2 (db, "TopoGeo_ToGeoTable", 5,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_ToGeoTable, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_ToGeoTable", 6,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_ToGeoTable, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_ToGeoTableGeneralize", 6,

static void
fnct_TopoGeo_AddLineString (sqlite3_context * context, int argc,
			    sqlite3_value ** argv)
{
    fnctaux_TopoGeo_AddLineString (context, argc, argv);
}

static void
fnct_TopoGeo_AddLineStringNoFace (sqlite3_context * context, int argc,
			    sqlite3_value ** argv)
{
    fnctaux_TopoGeo_AddLineStringNoFace (context, argc, argv);
}

static void
fnct_TopoGeo_FromGeoTable (sqlite3_context * context, int argc,
			   sqlite3_value ** argv)
{
    fnctaux_TopoGeo_FromGeoTable (context, argc, argv);
}

static void
fnct_TopoGeo_FromGeoTableNoFace (sqlite3_context * context, int argc,
			   sqlite3_value ** argv)
{
    fnctaux_TopoGeo_FromGeoTableNoFace (context, argc, argv);
}

static void
fnct_TopoGeo_FromGeoTableExt (sqlite3_context * context, int argc,
			      sqlite3_value ** argv)
{
    fnctaux_TopoGeo_FromGeoTableExt (context, argc, argv);
}

static void
fnct_TopoGeo_FromGeoTableNoFaceExt (sqlite3_context * context, int argc,
			      sqlite3_value ** argv)
{
    fnctaux_TopoGeo_FromGeoTableNoFaceExt (context, argc, argv);
}

static void
fnct_TopoGeo_Polygonize (sqlite3_context * context, int argc,
			      sqlite3_value ** argv)
{
    fnctaux_TopoGeo_Polygonize (context, argc, argv);
}

static void
fnct_TopoSnap (sqlite3_context * context, int argc,
			      sqlite3_value ** argv)
{
    fnctaux_TopoSnap (context, argc, argv);
}

static void
fnct_TopoGeo_ToGeoTable (sqlite3_context * context, int argc,
			 sqlite3_value ** argv)
{
    fnctaux_TopoGeo_ToGeoTable (context, argc, argv);
}
................................................................................
				      fnct_GetFaceByPoint, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_AddPoint", 3,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_AddPoint, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_AddLineString", 3,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_AddLineString, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_AddLineStringNoFace", 3,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_AddLineStringNoFace, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTable", 5,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTable, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTable", 7,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTable, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableNoFace", 5,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableNoFace, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableNoFace", 7,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableNoFace, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableExt", 7,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableExt, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableExt", 9,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableExt, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableNoFaceExt", 7,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableNoFaceExt, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_FromGeoTableNoFaceExt", 9,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_FromGeoTableNoFaceExt, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_Polygonize", 1,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_Polygonize, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "ST_TopoSnap", 5,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoSnap, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_ToGeoTable", 5,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_ToGeoTable, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_ToGeoTable", 6,
				      SQLITE_UTF8 | SQLITE_DETERMINISTIC, cache,
				      fnct_TopoGeo_ToGeoTable, 0, 0, 0);
	  sqlite3_create_function_v2 (db, "TopoGeo_ToGeoTableGeneralize", 6,

		*(p_vt->Format + i) = FDO_OGR_NONE;
		*(p_vt->CoordDimensions + i) = GAIA_XY;
	    }
	  for (i = 1; i <= n_rows; i++)
	    {
		col_name = results[(i * n_columns) + 0];
		type = atoi (results[(i * n_columns) + 1]);



		srid = atoi (results[(i * n_columns) + 2]);
		format = results[(i * n_columns) + 3];
		coord_dimension = atoi (results[(i * n_columns) + 4]);
		len = strlen (col_name);
		*(p_vt->GeoColumn + (i - 1)) = sqlite3_malloc (len + 1);
		strcpy (*(p_vt->GeoColumn + (i - 1)), col_name);
		*(p_vt->GeoType + (i - 1)) = type;
		*(p_vt->Srid + (i - 1)) = srid;

		*(p_vt->Format + i) = FDO_OGR_NONE;
		*(p_vt->CoordDimensions + i) = GAIA_XY;
	    }
	  for (i = 1; i <= n_rows; i++)
	    {
		col_name = results[(i * n_columns) + 0];
		type = atoi (results[(i * n_columns) + 1]);
		if (results[(i * n_columns) + 2] == NULL)
		    srid = -1;
		else
		    srid = atoi (results[(i * n_columns) + 2]);
		format = results[(i * n_columns) + 3];
		coord_dimension = atoi (results[(i * n_columns) + 4]);
		len = strlen (col_name);
		*(p_vt->GeoColumn + (i - 1)) = sqlite3_malloc (len + 1);
		strcpy (*(p_vt->GeoColumn + (i - 1)), col_name);
		*(p_vt->GeoType + (i - 1)) = type;
		*(p_vt->Srid + (i - 1)) = srid;

static struct sqlite3_module my_route_module;

#define VROUTE_DIJKSTRA_ALGORITHM	1
#define VROUTE_A_STAR_ALGORITHM	2

#define VROUTE_ROUTING_SOLUTION	0xdd
#define VROUTE_RANGE_SOLUTION		0xbb
#define VROUTE_TSP_SOLUTION		0xee

#define VROUTE_SHORTEST_PATH_FULL		0x70
#define VROUTE_SHORTEST_PATH_NO_ARCS	0x71
#define VROUTE_SHORTEST_PATH_NO_GEOMS	0x72
#define VROUTE_SHORTEST_PATH_SIMPLE		0x73

#define VROUTE_SHORTEST_PATH			0x91
#define VROUTE_TSP_NN					0x92


#define VROUTE_INVALID_SRID	-1234



#ifdef _WIN32
#define strcasecmp	_stricmp
#endif /* not WIN32 */

/******************************************************************************
/
................................................................................
typedef struct ShortestPathSolutionStruct
{
/* a shortest path solution */
    ArcSolutionPtr FirstArc;
    ArcSolutionPtr LastArc;
    RouteNodePtr From;
    RouteNodePtr To;

    RowSolutionPtr First;
    RowSolutionPtr Last;
    RowNodeSolutionPtr FirstNode;
    RowNodeSolutionPtr LastNode;
    RowNodeSolutionPtr CurrentNodeRow;
    double TotalCost;
    gaiaGeomCollPtr Geometry;
................................................................................
typedef struct ResultsetRowStruct
{
/* a row into the resultset */
    int RouteNum;
    int RouteRow;
    RouteNodePtr From;
    RouteNodePtr To;

    RowSolutionPtr linkRef;
    double TotalCost;
    gaiaGeomCollPtr Geometry;
    struct ResultsetRowStruct *Next;

} ResultsetRow;
typedef ResultsetRow *ResultsetRowPtr;
................................................................................
/* TSP helper struct */
    unsigned char Mode;
    double TotalCost;
    RouteNodePtr From;
    int Count;
    RouteNodePtr *To;
    char *Found;

    ShortestPathSolutionPtr First;
    ShortestPathSolutionPtr Last;
} TspTargets;
typedef TspTargets *TspTargetsPtr;











































/******************************************************************************
/
/ Dijkstra and A* common structs
/
******************************************************************************/

typedef struct RoutingNode
................................................................................
    pN = solution->FirstNode;
    while (pN)
      {
	  pNn = pN->Next;
	  free (pN);
	  pN = pNn;
      }


    if (solution->Geometry)
	gaiaFreeGeomColl (solution->Geometry);
    free (solution);
}

static ShortestPathSolutionPtr
alloc_solution (void)
................................................................................
{
/* allocates and initializes the current solution */
    ShortestPathSolutionPtr p = malloc (sizeof (ShortestPathSolution));
    p->FirstArc = NULL;
    p->LastArc = NULL;
    p->From = NULL;
    p->To = NULL;

    p->First = NULL;
    p->Last = NULL;
    p->FirstNode = NULL;
    p->LastNode = NULL;
    p->CurrentNodeRow = NULL;
    p->TotalCost = 0.0;
    p->Geometry = NULL;
................................................................................
	  int route_row = 0;
	  RowSolutionPtr pA;
	  ResultsetRowPtr row = malloc (sizeof (ResultsetRow));
	  row->RouteNum = route_num;
	  row->RouteRow = route_row++;
	  row->From = pS->From;
	  row->To = pS->To;


	  row->linkRef = NULL;
	  row->TotalCost = pS->TotalCost;
	  row->Geometry = pS->Geometry;
	  row->Next = NULL;
	  if (multiSolution->FirstRow == NULL)
	      multiSolution->FirstRow = row;
	  if (multiSolution->LastRow != NULL)
................................................................................
	    {
		/* inserting Route's traversed Arcs */
		row = malloc (sizeof (ResultsetRow));
		row->RouteNum = route_num;
		row->RouteRow = route_row++;
		row->From = NULL;
		row->To = NULL;

		row->linkRef = pA;
		row->TotalCost = 0.0;
		row->Geometry = NULL;
		row->Next = NULL;
		if (multiSolution->FirstRow == NULL)
		    multiSolution->FirstRow = row;
		if (multiSolution->LastRow != NULL)
................................................................................
	    }
	  route_num++;
	  pS = pS->Next;
      }
}

static void
aux_build_tsp (MultiSolutionPtr multiSolution, ShortestPathSolutionPtr pStart,
	       ShortestPathSolutionPtr pStop, int *route_num, int *route_row,
	       gaiaLinestringPtr tsp_path, int *point_index, int start)
{
/* helper function: formatting the TSP resultset */

    ResultsetRowPtr row;
    ShortestPathSolutionPtr pS = pStart;
    while (pS != NULL)
      {
	  /* inserting the Route Header */
	  RowSolutionPtr pA;
	  *route_row = 0;
	  row = malloc (sizeof (ResultsetRow));
	  row->RouteNum = *route_num;

	  row->RouteRow = *route_row;
	  *route_row += 1;
	  row->From = pS->From;
	  row->To = pS->To;

	  row->linkRef = NULL;
	  row->TotalCost = pS->TotalCost;
	  row->Geometry = pS->Geometry;
	  row->Next = NULL;
	  if (multiSolution->FirstRow == NULL)
	      multiSolution->FirstRow = row;
	  if (multiSolution->LastRow != NULL)
	      multiSolution->LastRow->Next = row;
	  multiSolution->LastRow = row;
	  /* adding the Geometry to the multiSolution list */
	  if (multiSolution->FirstGeom == NULL)
	      multiSolution->FirstGeom = pS->Geometry;
	  if (multiSolution->LastGeom != NULL)
	      multiSolution->LastGeom->Next = pS->Geometry;
	  multiSolution->LastGeom = pS->Geometry;
	  /* removing Geometry ownership form Solution */
	  pS->Geometry = NULL;

	  /* copying points into the TSP geometry */
	  if (tsp_path != NULL && row->Geometry != NULL)
	    {
		gaiaLinestringPtr ln = row->Geometry->FirstLinestring;
		if (ln != NULL)
		  {
		      int base;
		      int iv;
		      if (pS == pStart && start)
			  base = 0;
		      else
			  base = 1;
		      for (iv = base; iv < ln->Points; iv++)
			{
			    double x;
			    double y;
			    int pt = *point_index;
			    *point_index += 1;
			    gaiaGetPoint (ln->Coords, iv, &x, &y);
			    gaiaSetPoint (tsp_path->Coords, pt, x, y);
			}
		  }
	    }

	  pA = pS->First;
	  while (pA != NULL)
	    {
		/* inserting Route's traversed Arcs */
		row = malloc (sizeof (ResultsetRow));
		row->RouteNum = *route_num;
		row->RouteRow = *route_row;
		*route_row += 1;
		row->From = NULL;
		row->To = NULL;

		row->linkRef = pA;
		row->TotalCost = 0.0;
		row->Geometry = NULL;
		row->Next = NULL;
		if (multiSolution->FirstRow == NULL)
		    multiSolution->FirstRow = row;
		if (multiSolution->LastRow != NULL)
		    multiSolution->LastRow->Next = row;
		multiSolution->LastRow = row;
		/* adding the Arc to the multiSolution list */
		if (multiSolution->FirstArc == NULL)
		    multiSolution->FirstArc = pA;
		if (multiSolution->LastArc != NULL)
		    multiSolution->LastArc->Next = pA;
		multiSolution->LastArc = pA;
		pA = pA->Next;
	    }
	  *route_num += 1;
	  /* removing Arcs ownership form Solution */
	  pS->First = NULL;
	  pS->Last = NULL;
	  pS = pS->Next;
	  if (pS == pStop)
	      break;
      }
}




















static void
build_tsp_solution (MultiSolutionPtr multiSolution, TspTargetsPtr targets)
{
/* formatting the TSP resultset */

    ShortestPathSolutionPtr pS;
    ResultsetRowPtr row;

    int i;

    int unreachable = 0;
    int route_row = 0;
    int route_num = 0;
    int points = 0;
    gaiaLinestringPtr tsp_path = NULL;
    int srid = -1;
    int iv = 0;

/* checking for unreacheable targets */
    for (i = 0; i < targets->Count; i++)
      {
	  RouteNodePtr to = *(targets->To + i);
	  if (to == NULL)
	      continue;
	  if (*(targets->Found + i) != 'Y')
	      unreachable = 1;
      }

/* inserting the TSP Header */
    row = malloc (sizeof (ResultsetRow));
    row->RouteNum = route_num++;
    row->RouteRow = route_row++;
    row->From = targets->From;
    row->To = targets->From;

    row->linkRef = NULL;
    if (unreachable)
	row->TotalCost = 0.0;
    else
	row->TotalCost = targets->TotalCost;
    row->Geometry = NULL;
    row->Next = NULL;
................................................................................
		RouteNodePtr to = *(targets->To + i);
		if (to == NULL)
		    continue;
		if (*(targets->Found + i) != 'Y')
		  {
		      /* unreacheable target */
		      row = malloc (sizeof (ResultsetRow));
		      row->RouteNum = 0;
		      row->RouteRow = route_row++;
		      row->From = to;
		      row->To = to;

		      row->linkRef = NULL;
		      row->TotalCost = 0.0;
		      row->Geometry = NULL;
		      row->Next = NULL;
		      if (multiSolution->FirstRow == NULL)
			  multiSolution->FirstRow = row;
		      if (multiSolution->LastRow != NULL)
................................................................................
		      multiSolution->LastRow = row;
		  }
	    }
	  return;
      }

/* creating the TSP geometry */
    pS = targets->First;
    while (pS != NULL)
      {

	  gaiaGeomCollPtr geom = pS->Geometry;
	  if (geom != NULL)
	    {
		srid = geom->Srid;
		gaiaLinestringPtr ln = geom->FirstLinestring;
		if (ln != NULL)
		  {
		      if (pS == targets->First)
			  points += ln->Points;
		      else
			  points += ln->Points - 1;
		  }
	    }
	  pS = pS->Next;












      }
    if (points >= 2)
      {
	  row->Geometry = gaiaAllocGeomColl ();
	  row->Geometry->Srid = srid;
	  tsp_path = gaiaAddLinestringToGeomColl (row->Geometry, points);
	  /* adding the Geometry to the multiSolution list */
................................................................................
	  if (multiSolution->FirstGeom == NULL)
	      multiSolution->FirstGeom = row->Geometry;
	  if (multiSolution->LastGeom != NULL)
	      multiSolution->LastGeom->Next = row->Geometry;
	  multiSolution->LastGeom = row->Geometry;
      }





    if (multiSolution->From == targets->From)

      {
	  /* TSP solution already is in its right seguence */
	  aux_build_tsp (multiSolution, targets->First, NULL, &route_num,
			 &route_row, tsp_path, &iv, 1);











      }
    else


      {
	  /* reordering the TSP solution */
	  ShortestPathSolutionPtr pStart = NULL;



	  pS = targets->First;
	  while (pS != NULL)





	    {

		if (pS->From == multiSolution->From)
		  {
		      /* this one is the real TSP start node */
		      pStart = pS;

		      break;
		  }
























		pS = pS->Next;





	    }




	  if (pStart == NULL)
	      return;
	  aux_build_tsp (multiSolution, pStart, NULL, &route_num, &route_row,
			 tsp_path, &iv, 1);
	  aux_build_tsp (multiSolution, targets->First, pStart, &route_num,
			 &route_row, tsp_path, &iv, 0);




















      }


















}



static ShortestPathSolutionPtr
add2multiSolution (MultiSolutionPtr multiSolution, RouteNodePtr pfrom,
		   RouteNodePtr pto, RouteArcPtr * shortest_path, int cnt)
{
/* adding a route solution to a multiple destinations request */
    int i;
    ShortestPathSolutionPtr solution = alloc_solution ();
    solution->From = pfrom;
    solution->To = pto;
    if (multiSolution->First == NULL)
	multiSolution->First = solution;
    if (multiSolution->Last != NULL)
	multiSolution->Last->Next = solution;
    multiSolution->Last = solution;
    return solution;
    if (cnt > 0)
      {
	  /* building the solution */
	  for (i = 0; i < cnt; i++)
	      add_arc_to_solution (solution, shortest_path[i]);
      }




    return solution;
}

static ShortestPathSolutionPtr
add2tspSolution (TspTargetsPtr targets, RouteNodePtr pfrom,
		 RouteNodePtr pto, RouteArcPtr * shortest_path, int cnt)
{
/* adding a route solution to a TSP request */
    int i;
    ShortestPathSolutionPtr solution = alloc_solution ();
    solution->From = pfrom;
    solution->To = pto;
    if (targets->First == NULL)
	targets->First = solution;

    if (targets->Last != NULL)
	targets->Last->Next = solution;
    targets->Last = solution;
    return solution;
    if (cnt > 0)
      {
	  /* building the solution */
	  for (i = 0; i < cnt; i++)
	      add_arc_to_solution (solution, shortest_path[i]);



      }
    return solution;
}

static RouteNodePtr
check_multiTo (RoutingNodePtr node, RoutingMultiDestPtr multiple)
{
................................................................................
		      /* inserting an Arc into the solution */
		      result[k] = n->Arc;
		      n = n->PreviousNode;
		      k--;
		  }
		solution =
		    add2multiSolution (multiSolution, multiSolution->From,
				       destination, result, cnt);
		build_solution (handle, options, graph, solution, result, cnt);
		/* testing for end (all destinations already reached) */
		if (end_multiTo (multiSolution->MultiTo))
		    break;
























































































































	    }
	  n->Inspected = 1;
	  for (i = 0; i < n->DimTo; i++)
	    {
		p_to = *(n->To + i);
		p_link = *(n->Link + i);
		if (p_to->Inspected == 0)
................................................................................
    routing_heap_free (heap);
}

static void
destroy_tsp_targets (TspTargetsPtr targets)
{
/* memory cleanup; destroying a TSP helper struct */
    ShortestPathSolutionPtr pS;
    ShortestPathSolutionPtr pSn;

    if (targets == NULL)
	return;
    if (targets->To != NULL)
	free (targets->To);
    if (targets->Found != NULL)
	free (targets->Found);
    pS = targets->First;
    while (pS != NULL)

      {
	  pSn = pS->Next;





	  delete_solution (pS);
	  pS = pSn;
      }




    free (targets);
}

static TspTargetsPtr
randomize_targets (sqlite3 * handle, RoutingPtr graph,
		   MultiSolutionPtr multiSolution)
{
................................................................................
    int n_columns;
    const char *value = NULL;
    char **results;
    int from;
    TspTargetsPtr targets = malloc (sizeof (TspTargets));
    targets->Mode = multiSolution->Mode;
    targets->TotalCost = 0.0;
    targets->First = NULL;
    targets->Last = NULL;
    targets->Count = multiSolution->MultiTo->Items;
    targets->To = malloc (sizeof (RouteNodePtr *) * targets->Count);
    targets->Found = malloc (sizeof (char) * targets->Count);












    sql =
	sqlite3_mprintf ("SELECT %d, Random() AS rnd\n",
			 multiSolution->From->InternalIndex);
    for (i = 0; i < multiSolution->MultiTo->Items; i++)
      {
	  RouteNodePtr p_to = *(multiSolution->MultiTo->To + i);
................................................................................
      {
	  targets->From = multiSolution->From;
	  for (i = 0; i < multiSolution->MultiTo->Items; i++)
	    {
		RouteNodePtr p_to = *(multiSolution->MultiTo->To + i);
		*(targets->To + i) = p_to;
		*(targets->Found + i) = 'N';


	    }
      }
    else
      {
	  int j = 0;
	  targets->From = graph->Nodes + from;
	  *(targets->To + j++) = multiSolution->From;
	  for (i = 0; i < multiSolution->MultiTo->Items; i++)
	    {
		RouteNodePtr p_to = *(multiSolution->MultiTo->To + i);
		*(targets->Found + i) = 'N';


		if (p_to == targets->From)
		    continue;
		*(targets->To + j++) = p_to;
	    }
      }

    return targets;

  illegal:
    destroy_tsp_targets (targets);













    return NULL;
}

static RouteNodePtr
check_TspTo (RoutingNodePtr node, TspTargetsPtr targets)
{
/* testing TSP destinations */
    int i;
................................................................................
		while (n->PreviousNode != NULL)
		  {
		      /* inserting an Arc into the solution */
		      result[k] = n->Arc;
		      n = n->PreviousNode;
		      k--;
		  }

		solution =


		    add2tspSolution (targets, origin, destination, result, cnt);
		build_solution (handle, options, graph, solution, result, cnt);
		targets->TotalCost += solution->TotalCost;

		/* testing for end (all destinations already reached) */
		if (last_route)
		    break;
		if (end_TspTo (targets))
		  {
		      /* determining the final route so to close the circular trip */
		      last_route = 1;
		  }

		/* restarting from the current target */
		from = to;
		for (i = 0; i < e->Dim; i++)
		  {
................................................................................
    int i;
    const char *prev = str;
    const char *ptr = str;

/* populating a linked list */
    while (1)
      {

	  if (*ptr == '\0')
	    {
		item = vroute_parse_multiple_item (prev, ptr);
		addMultiCandidate (list, item);
		break;
	    }


	  if (*ptr == delimiter)
	    {
		item = vroute_parse_multiple_item (prev, ptr);
		addMultiCandidate (list, item);
		ptr++;
		prev = ptr;
		continue;
	    }
................................................................................
	  free (pN);
	  pN = pNn;
      }
    pR = multiSolution->FirstRow;
    while (pR != NULL)
      {
	  pRn = pR->Next;


	  free (pR);
	  pR = pRn;
      }
    pA = multiSolution->FirstArc;
    while (pA != NULL)
      {
	  pAn = pA->Next;
................................................................................
    ShortestPathSolutionPtr solution;
    RouteNodePtr to = findSingleTo (multiSolution->MultiTo);
    if (to == NULL)
	return;
    shortest_path =
	astar_shortest_path (routing, graph->Nodes, multiSolution->From,
			     to, graph->AStarHeuristicCoeff, &cnt);
    solution =
	add2multiSolution (multiSolution, multiSolution->From, to,
			   shortest_path, cnt);
    build_solution (handle, options, graph, solution, shortest_path, cnt);
    build_multi_solution (multiSolution);
}

static void
tsp_nn_solve (sqlite3 * handle, int options, RoutingPtr graph,
	      RoutingNodesPtr routing, MultiSolutionPtr multiSolution)
{
/* computing a Dijkstra TSP NN Solution */
    TspTargetsPtr targets = randomize_targets (handle, graph, multiSolution);
    if (targets == NULL)
	return;
    dijkstra_tsp_nn (handle, options, graph, routing, targets);
    build_tsp_solution (multiSolution, targets);
    destroy_tsp_targets (targets);
}

static void
dijkstra_multi_solve (sqlite3 * handle, int options, RoutingPtr graph,
		      RoutingNodesPtr routing, MultiSolutionPtr multiSolution)
{
/* computing a Dijkstra Shortest Path multiSolution */



    dijkstra_multi_shortest_path (handle, options, graph, routing,
				  multiSolution);


























    build_multi_solution (multiSolution);
}

static void
dijkstra_within_cost_range (RoutingNodesPtr routing,
			    MultiSolutionPtr multiSolution, int srid)
{
................................................................................
    int cnt;
    RoutingNodePtr *range_nodes =
	dijkstra_range_analysis (routing, multiSolution->From,
				 multiSolution->MaxCost,
				 &cnt);
    build_range_solution (multiSolution, range_nodes, cnt, srid);
}











































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































static void
network_free (RoutingPtr p)
{
/* memory cleanup; freeing any allocation for the network struct */
    RouteNodePtr pN;
    int i;
................................................................................
		  {
		      tsp_nn_solve (net->db, net->currentOptions, net->graph,
				    net->routing, cursor->pVtab->multiSolution);
		      cursor->pVtab->multiSolution->CurrentRowId = 0;
		      cursor->pVtab->multiSolution->CurrentRow =
			  cursor->pVtab->multiSolution->FirstRow;
		  }












	    }
	  else
	    {
		cursor->pVtab->multiSolution->Mode = VROUTE_ROUTING_SOLUTION;
		if (net->currentAlgorithm == VROUTE_A_STAR_ALGORITHM)
		    astar_solve (net->db, net->currentOptions, net->graph,
				 net->routing, cursor->pVtab->multiSolution);
................................................................................
					   SQLITE_TRANSIENT);
		  }
		else if (column == 1)
		  {
		      /* the current Request type */
		      if (net->currentRequest == VROUTE_TSP_NN)
			  algorithm = "TSP NN";


		      else
			  algorithm = "Shortest Path";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		else if (column == 2)
................................................................................
				   cursor->pVtab->currentDelimiter);
		      sqlite3_result_text (pContext, delimiter,
					   strlen (delimiter),
					   SQLITE_TRANSIENT);
		  }
		else
		    sqlite3_result_null (pContext);



































































































































		return SQLITE_OK;
	    }
	  if (row->linkRef == NULL)
	    {
		/* special case: this one is the solution summary */
		if (column == 0)
		  {
................................................................................
					   SQLITE_TRANSIENT);
		  }
		if (column == 1)
		  {
		      /* the current Request type */
		      if (net->currentRequest == VROUTE_TSP_NN)
			  algorithm = "TSP NN";


		      else
			  algorithm = "Shortest Path";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		if (column == 2)
................................................................................
		      sqlite3_result_int (pContext, row->RouteRow);
		  }
		if (column == 6)
		  {
		      /* role of this row */
		      if (cursor->pVtab->multiSolution->Mode ==
			  VROUTE_TSP_SOLUTION && row->RouteNum == 0)
			{
			    if (row->RouteRow == 0)
				role = "TSP Solution";
			    else


				role = "Unreachable City";
			}
		      else
			  role = "Route";

		      sqlite3_result_text (pContext, role, strlen (role),
					   SQLITE_TRANSIENT);
		  }
		if (row->From == NULL || row->To == NULL)
		  {
		      /* empty [uninitialized] solution */
		      if (column > 0)
................................................................................
					       SQLITE_STATIC);
		      else
			  sqlite3_result_int64 (pContext, row->To->Id);
		  }
		if (column == 10)
		  {
		      /* the Cost column */



		      sqlite3_result_double (pContext, row->TotalCost);
		  }
		if (column == 11)
		  {
		      /* the Geometry column */
		      if (!(row->Geometry))
			  sqlite3_result_null (pContext);
		      else
................................................................................
					   SQLITE_TRANSIENT);
		  }
		if (column == 1)
		  {
		      /* the current Request type */
		      if (net->currentRequest == VROUTE_TSP_NN)
			  algorithm = "TSP NN";


		      else
			  algorithm = "Shortest Path";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		if (column == 2)
................................................................................
			    const unsigned char *request =
				sqlite3_value_text (argv[3]);
			    if (strcasecmp ((char *) request, "TSP") == 0)
				p_vtab->currentRequest = VROUTE_TSP_NN;
			    else if (strcasecmp
				     ((char *) request, "TSP NN") == 0)
				p_vtab->currentRequest = VROUTE_TSP_NN;



			    else if (strcasecmp
				     ((char *) request, "SHORTEST PATH") == 0)
				p_vtab->currentRequest = VROUTE_SHORTEST_PATH;
			}
		      if (sqlite3_value_type (argv[4]) == SQLITE_TEXT)
			{
			    const unsigned char *options =

static struct sqlite3_module my_route_module;

#define VROUTE_DIJKSTRA_ALGORITHM	1
#define VROUTE_A_STAR_ALGORITHM	2

#define VROUTE_ROUTING_SOLUTION	0xdd
#define VROUTE_RANGE_SOLUTION	0xbb
#define VROUTE_TSP_SOLUTION		0xee

#define VROUTE_SHORTEST_PATH_FULL		0x70
#define VROUTE_SHORTEST_PATH_NO_ARCS	0x71
#define VROUTE_SHORTEST_PATH_NO_GEOMS	0x72
#define VROUTE_SHORTEST_PATH_SIMPLE		0x73

#define VROUTE_SHORTEST_PATH			0x91
#define VROUTE_TSP_NN					0x92
#define VROUTE_TSP_GA					0x93

#define VROUTE_INVALID_SRID	-1234

#define	VROUTE_TSP_GA_MAX_ITERATIONS	512

#ifdef _WIN32
#define strcasecmp	_stricmp
#endif /* not WIN32 */

/******************************************************************************
/
................................................................................
typedef struct ShortestPathSolutionStruct
{
/* a shortest path solution */
    ArcSolutionPtr FirstArc;
    ArcSolutionPtr LastArc;
    RouteNodePtr From;
    RouteNodePtr To;
    char *Undefined;
    RowSolutionPtr First;
    RowSolutionPtr Last;
    RowNodeSolutionPtr FirstNode;
    RowNodeSolutionPtr LastNode;
    RowNodeSolutionPtr CurrentNodeRow;
    double TotalCost;
    gaiaGeomCollPtr Geometry;
................................................................................
typedef struct ResultsetRowStruct
{
/* a row into the resultset */
    int RouteNum;
    int RouteRow;
    RouteNodePtr From;
    RouteNodePtr To;
    char *Undefined;
    RowSolutionPtr linkRef;
    double TotalCost;
    gaiaGeomCollPtr Geometry;
    struct ResultsetRowStruct *Next;

} ResultsetRow;
typedef ResultsetRow *ResultsetRowPtr;
................................................................................
/* TSP helper struct */
    unsigned char Mode;
    double TotalCost;
    RouteNodePtr From;
    int Count;
    RouteNodePtr *To;
    char *Found;
    double *Costs;
    ShortestPathSolutionPtr *Solutions;
    ShortestPathSolutionPtr LastSolution;
} TspTargets;
typedef TspTargets *TspTargetsPtr;

typedef struct TspGaSubDistanceStruct
{
/* a cache sub-item for storing TSP GA costs */
    RouteNodePtr CityTo;
    double Cost;
} TspGaSubDistance;
typedef TspGaSubDistance *TspGaSubDistancePtr;

typedef struct TspGaDistanceStruct
{
/* a cache item for storing TSP GA costs */
    RouteNodePtr CityFrom;
    int Cities;
    TspGaSubDistancePtr *Distances;
    int NearestIndex;
} TspGaDistance;
typedef TspGaDistance *TspGaDistancePtr;

typedef struct TspGaSolutionStruct
{
/* TSP GA solution struct */
    int Cities;
    RouteNodePtr *CitiesFrom;
    RouteNodePtr *CitiesTo;
    double *Costs;
    double TotalCost;
} TspGaSolution;
typedef TspGaSolution *TspGaSolutionPtr;

typedef struct TspGaPopulationStruct
{
/* TSP GA helper struct */
    int Count;
    int Cities;
    TspGaSolutionPtr *Solutions;
    TspGaSolutionPtr *Offsprings;
    TspGaDistancePtr *Distances;
    char *RandomSolutionsSql;
    char *RandomIntervalSql;
} TspGaPopulation;
typedef TspGaPopulation *TspGaPopulationPtr;

/******************************************************************************
/
/ Dijkstra and A* common structs
/
******************************************************************************/

typedef struct RoutingNode
................................................................................
    pN = solution->FirstNode;
    while (pN)
      {
	  pNn = pN->Next;
	  free (pN);
	  pN = pNn;
      }
    if (solution->Undefined != NULL)
	free (solution->Undefined);
    if (solution->Geometry)
	gaiaFreeGeomColl (solution->Geometry);
    free (solution);
}

static ShortestPathSolutionPtr
alloc_solution (void)
................................................................................
{
/* allocates and initializes the current solution */
    ShortestPathSolutionPtr p = malloc (sizeof (ShortestPathSolution));
    p->FirstArc = NULL;
    p->LastArc = NULL;
    p->From = NULL;
    p->To = NULL;
    p->Undefined = NULL;
    p->First = NULL;
    p->Last = NULL;
    p->FirstNode = NULL;
    p->LastNode = NULL;
    p->CurrentNodeRow = NULL;
    p->TotalCost = 0.0;
    p->Geometry = NULL;
................................................................................
	  int route_row = 0;
	  RowSolutionPtr pA;
	  ResultsetRowPtr row = malloc (sizeof (ResultsetRow));
	  row->RouteNum = route_num;
	  row->RouteRow = route_row++;
	  row->From = pS->From;
	  row->To = pS->To;
	  row->Undefined = pS->Undefined;
	  pS->Undefined = NULL;
	  row->linkRef = NULL;
	  row->TotalCost = pS->TotalCost;
	  row->Geometry = pS->Geometry;
	  row->Next = NULL;
	  if (multiSolution->FirstRow == NULL)
	      multiSolution->FirstRow = row;
	  if (multiSolution->LastRow != NULL)
................................................................................
	    {
		/* inserting Route's traversed Arcs */
		row = malloc (sizeof (ResultsetRow));
		row->RouteNum = route_num;
		row->RouteRow = route_row++;
		row->From = NULL;
		row->To = NULL;
		row->Undefined = NULL;
		row->linkRef = pA;
		row->TotalCost = 0.0;
		row->Geometry = NULL;
		row->Next = NULL;
		if (multiSolution->FirstRow == NULL)
		    multiSolution->FirstRow = row;
		if (multiSolution->LastRow != NULL)
................................................................................
	    }
	  route_num++;
	  pS = pS->Next;
      }
}

static void
aux_tsp_add_solution (MultiSolutionPtr multiSolution,
		      ShortestPathSolutionPtr pS, int *route_num,
		      gaiaLinestringPtr tsp_path, int *point_index, int mode)
{
/* helper function: adding a solutiont into the TSP resultset */
    RowSolutionPtr pA;
    ResultsetRowPtr row;

    int route_row = 0;

/* inserting the Route Header */


    row = malloc (sizeof (ResultsetRow));
    row->RouteNum = *route_num;
    *route_num += 1;
    row->RouteRow = route_row;
    route_row += 1;
    row->From = pS->From;
    row->To = pS->To;
    row->Undefined = NULL;
    row->linkRef = NULL;
    row->TotalCost = pS->TotalCost;
    row->Geometry = pS->Geometry;
    row->Next = NULL;
    if (multiSolution->FirstRow == NULL)
	multiSolution->FirstRow = row;
    if (multiSolution->LastRow != NULL)
	multiSolution->LastRow->Next = row;
    multiSolution->LastRow = row;
    /* adding the Geometry to the multiSolution list */
    if (multiSolution->FirstGeom == NULL)
	multiSolution->FirstGeom = pS->Geometry;
    if (multiSolution->LastGeom != NULL)
	multiSolution->LastGeom->Next = pS->Geometry;
    multiSolution->LastGeom = pS->Geometry;
    /* removing Geometry ownership form Solution */
    pS->Geometry = NULL;

    /* copying points into the TSP geometry */
    if (tsp_path != NULL && row->Geometry != NULL)
      {
	  gaiaLinestringPtr ln = row->Geometry->FirstLinestring;
	  if (ln != NULL)
	    {
		int base;
		int iv;
		if (!mode)
		    base = 0;
		else
		    base = 1;
		for (iv = base; iv < ln->Points; iv++)
		  {
		      double x;
		      double y;
		      int pt = *point_index;
		      *point_index += 1;
		      gaiaGetPoint (ln->Coords, iv, &x, &y);
		      gaiaSetPoint (tsp_path->Coords, pt, x, y);
		  }
	    }
      }

    pA = pS->First;
    while (pA != NULL)
      {
	  /* inserting Route's traversed Arcs */
	  row = malloc (sizeof (ResultsetRow));
	  row->RouteNum = *route_num;
	  row->RouteRow = route_row;
	  route_row += 1;
	  row->From = NULL;
	  row->To = NULL;
	  row->Undefined = NULL;
	  row->linkRef = pA;
	  row->TotalCost = 0.0;
	  row->Geometry = NULL;
	  row->Next = NULL;
	  if (multiSolution->FirstRow == NULL)
	      multiSolution->FirstRow = row;
	  if (multiSolution->LastRow != NULL)
	      multiSolution->LastRow->Next = row;
	  multiSolution->LastRow = row;
	  /* adding the Arc to the multiSolution list */
	  if (multiSolution->FirstArc == NULL)
	      multiSolution->FirstArc = pA;
	  if (multiSolution->LastArc != NULL)
	      multiSolution->LastArc->Next = pA;
	  multiSolution->LastArc = pA;
	  pA = pA->Next;
      }
    route_num += 1;
    /* removing Arcs ownership form Solution */
    pS->First = NULL;
    pS->Last = NULL;



}

static void
aux_build_tsp (MultiSolutionPtr multiSolution, TspTargetsPtr targets,
	       int route_num, gaiaLinestringPtr tsp_path)
{
/* helper function: formatting the TSP resultset */
    int point_index = 0;
    int i;
    for (i = 0; i < targets->Count; i++)
      {
	  /* adding all City to City solutions */
	  ShortestPathSolutionPtr pS = *(targets->Solutions + i);
	  aux_tsp_add_solution (multiSolution, pS, &route_num, tsp_path,
				&point_index, i);
      }
    /* adding the final trip closing the circular path */
    aux_tsp_add_solution (multiSolution, targets->LastSolution, &route_num,
			  tsp_path, &point_index, targets->Count);

}

static void
build_tsp_solution (MultiSolutionPtr multiSolution, TspTargetsPtr targets)
{
/* formatting the TSP resultset */
    ShortestPathSolutionPtr *oldS;
    ShortestPathSolutionPtr pS;
    ResultsetRowPtr row;
    RouteNodePtr from;
    int i;
    int k;
    int unreachable = 0;
    int route_row = 0;
    int route_num = 0;
    int points = 0;
    gaiaLinestringPtr tsp_path = NULL;
    int srid = -1;
    int found;

/* checking for undefined or unreacheable targets */
    for (i = 0; i < targets->Count; i++)
      {
	  RouteNodePtr to = *(targets->To + i);
	  if (to == NULL)
	      continue;
	  if (*(targets->Found + i) != 'Y')
	      unreachable = 1;
      }

/* inserting the TSP Header */
    row = malloc (sizeof (ResultsetRow));
    row->RouteNum = route_num++;
    row->RouteRow = route_row++;
    row->From = multiSolution->From;
    row->To = multiSolution->From;
    row->Undefined = NULL;
    row->linkRef = NULL;
    if (unreachable)
	row->TotalCost = 0.0;
    else
	row->TotalCost = targets->TotalCost;
    row->Geometry = NULL;
    row->Next = NULL;
................................................................................
		RouteNodePtr to = *(targets->To + i);
		if (to == NULL)
		    continue;
		if (*(targets->Found + i) != 'Y')
		  {
		      /* unreacheable target */
		      row = malloc (sizeof (ResultsetRow));
		      row->RouteNum = route_num++;
		      row->RouteRow = 0;
		      row->From = to;
		      row->To = to;
		      row->Undefined = NULL;
		      row->linkRef = NULL;
		      row->TotalCost = 0.0;
		      row->Geometry = NULL;
		      row->Next = NULL;
		      if (multiSolution->FirstRow == NULL)
			  multiSolution->FirstRow = row;
		      if (multiSolution->LastRow != NULL)
................................................................................
		      multiSolution->LastRow = row;
		  }
	    }
	  return;
      }

/* creating the TSP geometry */
    for (i = 0; i < targets->Count; i++)

      {
	  pS = *(targets->Solutions + i);
	  gaiaGeomCollPtr geom = pS->Geometry;
	  if (geom != NULL)
	    {
		srid = geom->Srid;
		gaiaLinestringPtr ln = geom->FirstLinestring;
		if (ln != NULL)
		  {
		      if (i == 0)
			  points += ln->Points;
		      else
			  points += ln->Points - 1;
		  }
	    }

      }
    if (targets->LastSolution != NULL)
      {
	  gaiaGeomCollPtr geom = targets->LastSolution->Geometry;
	  if (geom != NULL)
	    {
		gaiaLinestringPtr ln = geom->FirstLinestring;
		if (ln != NULL)
		  {
		      points += ln->Points - 1;
		  }
	    }
      }
    if (points >= 2)
      {
	  row->Geometry = gaiaAllocGeomColl ();
	  row->Geometry->Srid = srid;
	  tsp_path = gaiaAddLinestringToGeomColl (row->Geometry, points);
	  /* adding the Geometry to the multiSolution list */
................................................................................
	  if (multiSolution->FirstGeom == NULL)
	      multiSolution->FirstGeom = row->Geometry;
	  if (multiSolution->LastGeom != NULL)
	      multiSolution->LastGeom->Next = row->Geometry;
	  multiSolution->LastGeom = row->Geometry;
      }

    /* reordering the TSP solution */
    oldS = targets->Solutions;
    targets->Solutions =
	malloc (sizeof (ShortestPathSolutionPtr) * targets->Count);
    from = multiSolution->From;
    for (k = 0; k < targets->Count; k++)
      {



	  /* building the right sequence */
	  found = 0;
	  for (i = 0; i < targets->Count; i++)
	    {
		pS = *(oldS + i);
		if (pS->From == from)
		  {
		      *(targets->Solutions + k) = pS;
		      from = pS->To;
		      found = 1;
		      break;
		  }

	    }
	  if (!found)
	    {


		if (targets->LastSolution->From == from)
		  {
		      *(targets->Solutions + k) = targets->LastSolution;
		      from = targets->LastSolution->To;

		  }
	    }
      }
    /* adjusting the last route so to close a circular path */
    for (i = 0; i < targets->Count; i++)
      {
	  pS = *(oldS + i);
	  if (pS->From == from)
	    {


		targets->LastSolution = pS;
		break;
	    }
      }
    free (oldS);
    aux_build_tsp (multiSolution, targets, route_num, tsp_path);
}

static void
build_tsp_illegal_solution (MultiSolutionPtr multiSolution,
			    TspTargetsPtr targets)
{
/* formatting the TSP resultset - undefined targets */
    ResultsetRowPtr row;
    int i;
    int route_num = 0;

/* inserting the TSP Header */
    row = malloc (sizeof (ResultsetRow));
    row->RouteNum = route_num++;
    row->RouteRow = 0;
    row->From = multiSolution->From;
    row->To = multiSolution->From;
    row->Undefined = NULL;
    row->linkRef = NULL;
    row->TotalCost = 0.0;
    row->Geometry = NULL;
    row->Next = NULL;
    if (multiSolution->FirstRow == NULL)
	multiSolution->FirstRow = row;
    if (multiSolution->LastRow != NULL)
	multiSolution->LastRow->Next = row;
    multiSolution->LastRow = row;

    for (i = 0; i < targets->Count; i++)
      {
	  RouteNodePtr to = *(targets->To + i);
	  const char *code = *(multiSolution->MultiTo->Codes + i);
	  if (to == NULL)





	    {
		/* unknown target */
		int len;
		row = malloc (sizeof (ResultsetRow));
		row->RouteNum = route_num++;
		row->RouteRow = 0;
		row->From = to;
		row->To = to;
		len = strlen (code);
		row->Undefined = malloc (len + 1);
		strcpy (row->Undefined, code);
		row->linkRef = NULL;
		row->TotalCost = 0.0;
		row->Geometry = NULL;
		row->Next = NULL;
		if (multiSolution->FirstRow == NULL)
		    multiSolution->FirstRow = row;
		if (multiSolution->LastRow != NULL)
		    multiSolution->LastRow->Next = row;
		multiSolution->LastRow = row;
	    }
	  if (*(targets->Found + i) != 'Y')
	    {
		/* unreachable target */
		row = malloc (sizeof (ResultsetRow));
		row->RouteNum = route_num++;
		row->RouteRow = 0;
		row->From = to;
		row->To = to;
		row->Undefined = NULL;
		row->linkRef = NULL;
		row->TotalCost = 0.0;
		row->Geometry = NULL;
		row->Next = NULL;
		if (multiSolution->FirstRow == NULL)
		    multiSolution->FirstRow = row;
		if (multiSolution->LastRow != NULL)
		    multiSolution->LastRow->Next = row;
		multiSolution->LastRow = row;
	    }
      }
}

static ShortestPathSolutionPtr
add2multiSolution (MultiSolutionPtr multiSolution, RouteNodePtr pfrom,
		   RouteNodePtr pto)
{
/* adding a route solution to a multiple destinations request */

    ShortestPathSolutionPtr solution = alloc_solution ();
    solution->From = pfrom;
    solution->To = pto;
    if (multiSolution->First == NULL)
	multiSolution->First = solution;
    if (multiSolution->Last != NULL)
	multiSolution->Last->Next = solution;
    multiSolution->Last = solution;
    return solution;
}

static ShortestPathSolutionPtr
add2tspLastSolution (TspTargetsPtr targets, RouteNodePtr from, RouteNodePtr to)
{
/* adding the last route solution to a TSP request */
    ShortestPathSolutionPtr solution = alloc_solution ();
    solution->From = from;
    solution->To = to;
    targets->LastSolution = solution;
    return solution;
}

static ShortestPathSolutionPtr
add2tspSolution (TspTargetsPtr targets, RouteNodePtr from, RouteNodePtr to)

{
/* adding a route solution to a TSP request */
    int i;
    ShortestPathSolutionPtr solution = alloc_solution ();
    solution->From = from;
    solution->To = to;
    for (i = 0; i < targets->Count; i++)

      {
	  if (*(targets->To + i) == to)




	    {



		*(targets->Solutions + i) = solution;
		break;
	    }
      }
    return solution;
}

static RouteNodePtr
check_multiTo (RoutingNodePtr node, RoutingMultiDestPtr multiple)
{
................................................................................
		      /* inserting an Arc into the solution */
		      result[k] = n->Arc;
		      n = n->PreviousNode;
		      k--;
		  }
		solution =
		    add2multiSolution (multiSolution, multiSolution->From,
				       destination);
		build_solution (handle, options, graph, solution, result, cnt);
		/* testing for end (all destinations already reached) */
		if (end_multiTo (multiSolution->MultiTo))
		    break;
	    }
	  n->Inspected = 1;
	  for (i = 0; i < n->DimTo; i++)
	    {
		p_to = *(n->To + i);
		p_link = *(n->Link + i);
		if (p_to->Inspected == 0)
		  {
		      if (p_to->Distance == DBL_MAX)
			{
			    /* queuing a new node into the heap */
			    p_to->Distance = n->Distance + p_link->Cost;
			    p_to->PreviousNode = n;
			    p_to->Arc = p_link;
			    dijkstra_enqueue (heap, p_to);
			}
		      else if (p_to->Distance > n->Distance + p_link->Cost)
			{
			    /* updating an already inserted node */
			    p_to->Distance = n->Distance + p_link->Cost;
			    p_to->PreviousNode = n;
			    p_to->Arc = p_link;
			}
		  }
	    }
      }
    routing_heap_free (heap);
}

static RouteNodePtr
check_targets (RoutingNodePtr node, TspTargetsPtr targets)
{
/* testing targets */
    int i;
    for (i = 0; i < targets->Count; i++)
      {
	  RouteNodePtr to = *(targets->To + i);
	  if (to == NULL)
	      continue;
	  if (*(targets->Found + i) == 'Y')
	      continue;
	  if (node->Id == to->InternalIndex)
	    {
		*(targets->Found + i) = 'Y';
		return to;
	    }
      }
    return NULL;
}

static void
update_targets (TspTargetsPtr targets, RouteNodePtr destination, double cost,
		int *stop)
{
/* tupdating targets */
    int i;
    *stop = 1;
    for (i = 0; i < targets->Count; i++)
      {
	  RouteNodePtr to = *(targets->To + i);
	  if (to == NULL)
	      continue;
	  if (to == destination)
	      *(targets->Costs + i) = cost;
	  if (*(targets->Found + i) == 'Y')
	      continue;
	  *stop = 0;
      }
}


static void
dijkstra_targets_solve (RoutingNodesPtr e, TspTargetsPtr targets)
{
/* Shortest Path (multiple destinations) for TSP GA */
    int from;
    int i;
    RouteNodePtr destination;
    RoutingNodePtr n;
    RoutingNodePtr p_to;
    RouteArcPtr p_link;
    RoutingHeapPtr heap;
/* setting From */
    from = targets->From->InternalIndex;
/* initializing the heap */
    heap = routing_heap_init (e->DimLink);
/* initializing the graph */
    for (i = 0; i < e->Dim; i++)
      {
	  n = e->Nodes + i;
	  n->PreviousNode = NULL;
	  n->Arc = NULL;
	  n->Inspected = 0;
	  n->Distance = DBL_MAX;
      }
/* queuing the From node into the heap */
    e->Nodes[from].Distance = 0.0;
    dijkstra_enqueue (heap, e->Nodes + from);
    while (heap->Count > 0)
      {
	  /* Dijsktra loop */
	  n = routing_dequeue (heap);
	  destination = check_targets (n, targets);
	  if (destination != NULL)
	    {
		/* reached one of the targets */
		int stop = 0;
		double totalCost = 0.0;
		int to = destination->InternalIndex;
		n = e->Nodes + to;
		while (n->PreviousNode != NULL)
		  {
		      /* computing the total Cost */
		      totalCost += n->Arc->Cost;
		      n = n->PreviousNode;
		  }
		/* updating targets */
		update_targets (targets, destination, totalCost, &stop);
		if (stop)
		    break;
	    }
	  n->Inspected = 1;
	  for (i = 0; i < n->DimTo; i++)
	    {
		p_to = *(n->To + i);
		p_link = *(n->Link + i);
		if (p_to->Inspected == 0)
................................................................................
    routing_heap_free (heap);
}

static void
destroy_tsp_targets (TspTargetsPtr targets)
{
/* memory cleanup; destroying a TSP helper struct */



    if (targets == NULL)
	return;
    if (targets->To != NULL)
	free (targets->To);
    if (targets->Found != NULL)
	free (targets->Found);
    if (targets->Costs != NULL)
	free (targets->Costs);
    if (targets->Solutions != NULL)
      {

	  int i;
	  for (i = 0; i < targets->Count; i++)
	    {
		ShortestPathSolutionPtr pS = *(targets->Solutions + i);
		if (pS != NULL)
		    delete_solution (pS);

	    }
	  free (targets->Solutions);
      }
    if (targets->LastSolution != NULL)
	delete_solution (targets->LastSolution);
    free (targets);
}

static TspTargetsPtr
randomize_targets (sqlite3 * handle, RoutingPtr graph,
		   MultiSolutionPtr multiSolution)
{
................................................................................
    int n_columns;
    const char *value = NULL;
    char **results;
    int from;
    TspTargetsPtr targets = malloc (sizeof (TspTargets));
    targets->Mode = multiSolution->Mode;
    targets->TotalCost = 0.0;


    targets->Count = multiSolution->MultiTo->Items;
    targets->To = malloc (sizeof (RouteNodePtr *) * targets->Count);
    targets->Found = malloc (sizeof (char) * targets->Count);
    targets->Costs = malloc (sizeof (double) * targets->Count);
    targets->Solutions =
	malloc (sizeof (ShortestPathSolutionPtr) * targets->Count);
    targets->LastSolution = NULL;
    for (i = 0; i < targets->Count; i++)
      {
	  *(targets->To + i) = NULL;
	  *(targets->Found + i) = 'N';
	  *(targets->Costs + i) = DBL_MAX;
	  *(targets->Solutions + i) = NULL;
      }

    sql =
	sqlite3_mprintf ("SELECT %d, Random() AS rnd\n",
			 multiSolution->From->InternalIndex);
    for (i = 0; i < multiSolution->MultiTo->Items; i++)
      {
	  RouteNodePtr p_to = *(multiSolution->MultiTo->To + i);
................................................................................
      {
	  targets->From = multiSolution->From;
	  for (i = 0; i < multiSolution->MultiTo->Items; i++)
	    {
		RouteNodePtr p_to = *(multiSolution->MultiTo->To + i);
		*(targets->To + i) = p_to;
		*(targets->Found + i) = 'N';
		*(targets->Costs + i) = DBL_MAX;
		*(targets->Solutions + i) = NULL;
	    }
      }
    else
      {
	  int j = 0;
	  targets->From = graph->Nodes + from;
	  *(targets->To + j++) = multiSolution->From;
	  for (i = 0; i < multiSolution->MultiTo->Items; i++)
	    {
		RouteNodePtr p_to = *(multiSolution->MultiTo->To + i);
		*(targets->Found + i) = 'N';
		*(targets->Costs + i) = DBL_MAX;
		*(targets->Solutions + i) = NULL;
		if (p_to == targets->From)
		    continue;
		*(targets->To + j++) = p_to;
	    }
      }

    return targets;

  illegal:
    for (i = 0; i < targets->Count; i++)
      {
	  *(targets->To + i) = NULL;
	  *(targets->Found + i) = 'N';
	  *(targets->Costs + i) = DBL_MAX;
	  *(targets->Solutions + i) = NULL;
      }
    for (i = 0; i < multiSolution->MultiTo->Items; i++)
      {
	  RouteNodePtr p_to = *(multiSolution->MultiTo->To + i);
	  if (p_to == NULL)
	      continue;
	  *(targets->To + i) = p_to;
      }
    return targets;
}

static RouteNodePtr
check_TspTo (RoutingNodePtr node, TspTargetsPtr targets)
{
/* testing TSP destinations */
    int i;
................................................................................
		while (n->PreviousNode != NULL)
		  {
		      /* inserting an Arc into the solution */
		      result[k] = n->Arc;
		      n = n->PreviousNode;
		      k--;
		  }
		if (last_route)
		    solution =
			add2tspLastSolution (targets, origin, destination);
		else
		    solution = add2tspSolution (targets, origin, destination);
		build_solution (handle, options, graph, solution, result, cnt);
		targets->TotalCost += solution->TotalCost;

		/* testing for end (all destinations already reached) */
		if (last_route)
		    break;
		if (end_TspTo (targets))
		  {
		      /* determining the final route so to close the circular path */
		      last_route = 1;
		  }

		/* restarting from the current target */
		from = to;
		for (i = 0; i < e->Dim; i++)
		  {
................................................................................
    int i;
    const char *prev = str;
    const char *ptr = str;

/* populating a linked list */
    while (1)
      {
	  int whitespace = 0;
	  if (*ptr == '\0')
	    {
		item = vroute_parse_multiple_item (prev, ptr);
		addMultiCandidate (list, item);
		break;
	    }
	  if (*ptr == ' ' || *ptr == '\t' || *ptr == '\n' || *ptr == '\r')
	      whitespace = 1;
	  if (*ptr == delimiter || whitespace)
	    {
		item = vroute_parse_multiple_item (prev, ptr);
		addMultiCandidate (list, item);
		ptr++;
		prev = ptr;
		continue;
	    }
................................................................................
	  free (pN);
	  pN = pNn;
      }
    pR = multiSolution->FirstRow;
    while (pR != NULL)
      {
	  pRn = pR->Next;
	  if (pR->Undefined != NULL)
	      free (pR->Undefined);
	  free (pR);
	  pR = pRn;
      }
    pA = multiSolution->FirstArc;
    while (pA != NULL)
      {
	  pAn = pA->Next;
................................................................................
    ShortestPathSolutionPtr solution;
    RouteNodePtr to = findSingleTo (multiSolution->MultiTo);
    if (to == NULL)
	return;
    shortest_path =
	astar_shortest_path (routing, graph->Nodes, multiSolution->From,
			     to, graph->AStarHeuristicCoeff, &cnt);

    solution = add2multiSolution (multiSolution, multiSolution->From, to);

    build_solution (handle, options, graph, solution, shortest_path, cnt);
    build_multi_solution (multiSolution);
}














static void
dijkstra_multi_solve (sqlite3 * handle, int options, RoutingPtr graph,
		      RoutingNodesPtr routing, MultiSolutionPtr multiSolution)
{
/* computing a Dijkstra Shortest Path multiSolution */
    int i;
    RoutingMultiDestPtr multiple = multiSolution->MultiTo;

    dijkstra_multi_shortest_path (handle, options, graph, routing,
				  multiSolution);
/* testing if there are undefined or unresolved destinations */
    for (i = 0; i < multiple->Items; i++)
      {
	  int len;
	  ShortestPathSolutionPtr row;
	  RouteNodePtr to = *(multiple->To + i);
	  const char *code = *(multiple->Codes + i);
	  if (to == NULL)
	    {
		row =
		    add2multiSolution (multiSolution, multiSolution->From,
				       NULL);
		len = strlen (code);
		row->Undefined = malloc (len + 1);
		strcpy (row->Undefined, code);
		continue;
	    }
	  if (*(multiple->Found + i) != 'Y')
	    {
		row =
		    add2multiSolution (multiSolution, multiSolution->From, to);
		len = strlen (code);
		row->Undefined = malloc (len + 1);
		strcpy (row->Undefined, code);
	    }
      }
    build_multi_solution (multiSolution);
}

static void
dijkstra_within_cost_range (RoutingNodesPtr routing,
			    MultiSolutionPtr multiSolution, int srid)
{
................................................................................
    int cnt;
    RoutingNodePtr *range_nodes =
	dijkstra_range_analysis (routing, multiSolution->From,
				 multiSolution->MaxCost,
				 &cnt);
    build_range_solution (multiSolution, range_nodes, cnt, srid);
}

static void
tsp_nn_solve (sqlite3 * handle, int options, RoutingPtr graph,
	      RoutingNodesPtr routing, MultiSolutionPtr multiSolution)
{
/* computing a Dijkstra TSP NN Solution */
    int i;
    TspTargetsPtr targets = randomize_targets (handle, graph, multiSolution);
    for (i = 0; i < targets->Count; i++)
      {
	  /* checking for undefined targets */
	  if (*(targets->To + i) == NULL)
	      goto illegal;
      }
    dijkstra_tsp_nn (handle, options, graph, routing, targets);
    build_tsp_solution (multiSolution, targets);
    destroy_tsp_targets (targets);
    return;

  illegal:
    build_tsp_illegal_solution (multiSolution, targets);
    destroy_tsp_targets (targets);
}

static void
tsp_ga_random_solutions_sql (TspGaPopulationPtr ga)
{
/* building the Solutions randomizing SQL query */
    int i;
    char *sql;
    char *prev_sql;

    for (i = 0; i < ga->Count; i++)
      {
	  if (i == 0)
	      sql = sqlite3_mprintf ("SELECT %d, Random() AS rnd\n", i);
	  else
	    {
		prev_sql = sql;
		sql =
		    sqlite3_mprintf ("%sUNION\nSELECT %d, Random() AS rnd\n",
				     prev_sql, i);
		sqlite3_free (prev_sql);
	    }
      }
    prev_sql = sql;
    sql = sqlite3_mprintf ("%sORDER BY rnd LIMIT 2", prev_sql);
    sqlite3_free (prev_sql);
    ga->RandomSolutionsSql = sql;
}

static void
tsp_ga_random_interval_sql (TspGaPopulationPtr ga)
{
/* building the Interval randomizing SQL query */
    int i;
    char *sql;
    char *prev_sql;

    for (i = 0; i < ga->Cities; i++)
      {
	  if (i == 0)
	      sql = sqlite3_mprintf ("SELECT %d, Random() AS rnd\n", i);
	  else
	    {
		prev_sql = sql;
		sql =
		    sqlite3_mprintf ("%sUNION\nSELECT %d, Random() AS rnd\n",
				     prev_sql, i);
		sqlite3_free (prev_sql);
	    }
      }
    prev_sql = sql;
    sql = sqlite3_mprintf ("%sORDER BY rnd LIMIT 2", prev_sql);
    sqlite3_free (prev_sql);
    ga->RandomIntervalSql = sql;
}

static TspGaDistancePtr
alloc_tsp_ga_distances (TspTargetsPtr targets)
{
/* allocating a TSP GA distances struct */
    int i;
    TspGaDistancePtr dist = malloc (sizeof (TspGaDistance));
    dist->Cities = targets->Count;
    dist->CityFrom = targets->From;
    dist->Distances = malloc (sizeof (TspGaSubDistancePtr) * dist->Cities);
    for (i = 0; i < dist->Cities; i++)
      {
	  TspGaSubDistancePtr sub = malloc (sizeof (TspGaSubDistance));
	  double cost = *(targets->Costs + i);
	  sub->CityTo = *(targets->To + i);
	  sub->Cost = cost;
	  *(dist->Distances + i) = sub;
      }
    dist->NearestIndex = -1;
    return dist;
}

static void
destroy_tsp_ga_distances (TspGaDistancePtr dist)
{
/* freeing a TSP GA distance struct */
    if (dist == NULL)
	return;
    if (dist->Distances != NULL)
      {
	  int i;
	  for (i = 0; i < dist->Cities; i++)
	    {
		TspGaSubDistancePtr sub = *(dist->Distances + i);
		if (sub != NULL)
		    free (sub);
	    }
	  free (dist->Distances);
      }
    free (dist);
}

static TspGaPopulationPtr
build_tsp_ga_population (int count)
{
/* creating a TSP GA Population */
    int i;
    TspGaPopulationPtr ga = malloc (sizeof (TspGaPopulation));
    ga->Count = count;
    ga->Cities = count;
    ga->Solutions = malloc (sizeof (TspGaSolutionPtr) * count);
    ga->Offsprings = malloc (sizeof (TspGaSolutionPtr) * count);
    for (i = 0; i < count; i++)
      {
	  *(ga->Offsprings + i) = NULL;
	  *(ga->Solutions + i) = NULL;
      }
    ga->Distances = malloc (sizeof (TspGaDistancePtr) * count);
    for (i = 0; i < count; i++)
	*(ga->Distances + i) = NULL;
    ga->RandomSolutionsSql = NULL;
    tsp_ga_random_solutions_sql (ga);
    ga->RandomIntervalSql = NULL;
    tsp_ga_random_interval_sql (ga);
    return ga;
}

static void
destroy_tsp_ga_solution (TspGaSolutionPtr solution)
{
/* memory cleanup: destroyng a GA Solution */
    if (solution == NULL)
	return;
    if (solution->CitiesFrom != NULL)
	free (solution->CitiesFrom);
    if (solution->CitiesTo != NULL)
	free (solution->CitiesTo);
    if (solution->Costs != NULL)
	free (solution->Costs);
    free (solution);
}

static void
free_tsp_ga_offsprings (TspGaPopulationPtr ga)
{
/* memory cleanup; freeing GA Offsprings */
    int i;
    if (ga == NULL)
	return;

    for (i = 0; i < ga->Count; i++)
      {
	  if (*(ga->Offsprings + i) != NULL)
	      destroy_tsp_ga_solution (*(ga->Offsprings + i));
	  *(ga->Offsprings + i) = NULL;
      }
}

static void
destroy_tsp_ga_population (TspGaPopulationPtr ga)
{
/* memory cleanup; destroyng a GA Population */
    int i;
    if (ga == NULL)
	return;

    for (i = 0; i < ga->Count; i++)
	destroy_tsp_ga_solution (*(ga->Solutions + i));
    free (ga->Solutions);
    free_tsp_ga_offsprings (ga);
    free (ga->Offsprings);
    if (ga->Distances != NULL)
      {
	  for (i = 0; i < ga->Cities; i++)
	    {
		TspGaDistancePtr dist = *(ga->Distances + i);
		if (dist != NULL)
		    destroy_tsp_ga_distances (dist);
	    }
      }
    free (ga->Distances);
    if (ga->RandomSolutionsSql != NULL)
	sqlite3_free (ga->RandomSolutionsSql);
    if (ga->RandomIntervalSql != NULL)
	sqlite3_free (ga->RandomIntervalSql);
    free (ga);
}

static int
cmp_dist_from (const void *p1, const void *p2)
{
/* compares FROM distances [for BSEARCH] */
    TspGaDistancePtr pD1 = (TspGaDistancePtr) p1;
    TspGaDistancePtr pD2 = *((TspGaDistancePtr *) p2);
    RouteNodePtr pN1 = pD1->CityFrom;
    RouteNodePtr pN2 = pD2->CityFrom;
    if (pN1 == pN2)
	return 0;
    if (pN1 > pN2)
	return 1;
    return -1;
}

static TspGaDistancePtr
tsp_ga_find_from_distance (TspGaPopulationPtr ga, RouteNodePtr from)
{
/* searching the main FROM distance */
    TspGaDistancePtr *ret;
    TspGaDistance dist;
    dist.CityFrom = from;
    ret =
	bsearch (&dist, ga->Distances, ga->Cities, sizeof (TspGaDistancePtr),
		 cmp_dist_from);
    if (ret == NULL)
	return NULL;
    return *ret;
}

static int
cmp_dist_to (const void *p1, const void *p2)
{
/* compares TO distances [for BSEARCH] */
    TspGaSubDistancePtr pD1 = (TspGaSubDistancePtr) p1;
    TspGaSubDistancePtr pD2 = *((TspGaSubDistancePtr *) p2);
    RouteNodePtr pN1 = pD1->CityTo;
    RouteNodePtr pN2 = pD2->CityTo;
    if (pN1 == pN2)
	return 0;
    if (pN1 > pN2)
	return 1;
    return -1;
}

static TspGaSubDistancePtr
tsp_ga_find_to_distance (TspGaDistancePtr dist, RouteNodePtr to)
{
/* searching the main FROM distance */
    TspGaSubDistancePtr *ret;
    TspGaSubDistance sub;
    sub.CityTo = to;
    ret =
	bsearch (&sub, dist->Distances, dist->Cities,
		 sizeof (TspGaSubDistancePtr), cmp_dist_to);
    if (ret == NULL)
	return NULL;
    return *ret;
}

static double
tsp_ga_find_distance (TspGaPopulationPtr ga, RouteNodePtr from, RouteNodePtr to)
{
/* searching a cached distance */
    TspGaSubDistancePtr sub;
    TspGaDistancePtr dist = tsp_ga_find_from_distance (ga, from);
    if (dist == NULL)
	return DBL_MAX;

    sub = tsp_ga_find_to_distance (dist, to);
    if (sub != NULL)
	return sub->Cost;
    return DBL_MAX;
}

static void
tsp_ga_random_solutions (sqlite3 * handle, TspGaPopulationPtr ga, int *index1,
			 int *index2)
{
/* fetching two random TSP GA solutions */
    int i;
    int ret;
    int n_rows;
    int n_columns;
    const char *value = NULL;
    char **results;

    *index1 = -1;
    *index2 = -1;

    ret =
	sqlite3_get_table (handle, ga->RandomSolutionsSql, &results, &n_rows,
			   &n_columns, NULL);
    if (ret != SQLITE_OK)
	return;
    if (n_rows >= 1)
      {
	  for (i = 1; i <= n_rows; i++)
	    {
		value = results[(i * n_columns) + 0];
		if (i == 1)
		    *index1 = atoi (value);
		else
		    *index2 = atoi (value);
	    }
      }
    sqlite3_free_table (results);
}

static void
tsp_ga_random_interval (sqlite3 * handle, TspGaPopulationPtr ga, int *index1,
			int *index2)
{
/* fetching a random TSP GA interval */
    int i;
    int ret;
    int n_rows;
    int n_columns;
    const char *value = NULL;
    char **results;

    *index1 = -1;
    *index2 = -1;

    ret =
	sqlite3_get_table (handle, ga->RandomIntervalSql, &results, &n_rows,
			   &n_columns, NULL);
    if (ret != SQLITE_OK)
	return;
    if (n_rows >= 1)
      {
	  for (i = 1; i <= n_rows; i++)
	    {
		value = results[(i * n_columns) + 0];
		if (i == 1)
		    *index1 = atoi (value);
		else
		    *index2 = atoi (value);
	    }
      }
    sqlite3_free_table (results);
}

static void
tps_ga_chromosome_update (TspGaSolutionPtr chromosome, RouteNodePtr from,
			  RouteNodePtr to, double cost)
{
/* updating a chromosome (missing distance) */
    int j;
    for (j = 0; j < chromosome->Cities; j++)
      {
	  RouteNodePtr n1 = *(chromosome->CitiesFrom + j);
	  RouteNodePtr n2 = *(chromosome->CitiesTo + j);
	  if (n1 == from && n2 == to)
	      *(chromosome->Costs + j) = cost;
      }
}

static void
tsp_ga_random_mutation (sqlite3 * handle, TspGaPopulationPtr ga,
			TspGaSolutionPtr mutant)
{
/* introducing a random mutation */
    RouteNodePtr mutation;
    int j;
    int idx1;
    int idx2;

/* applying a random mutation */
    tsp_ga_random_interval (handle, ga, &idx1, &idx2);
    mutation = *(mutant->CitiesFrom + idx1);
    *(mutant->CitiesFrom + idx1) = *(mutant->CitiesFrom + idx2);
    *(mutant->CitiesFrom + idx2) = mutation;

/* adjusting From/To */
    for (j = 1; j < mutant->Cities; j++)
      {
	  RouteNodePtr pFrom = *(mutant->CitiesFrom + j);
	  *(mutant->CitiesTo + j - 1) = pFrom;
      }
    *(mutant->CitiesTo + mutant->Cities - 1) = *(mutant->CitiesFrom + 0);

/* adjusting Costs */
    mutant->TotalCost = 0.0;
    for (j = 0; j < mutant->Cities; j++)
      {
	  RouteNodePtr pFrom = *(mutant->CitiesFrom + j);
	  RouteNodePtr pTo = *(mutant->CitiesTo + j);
	  double cost = tsp_ga_find_distance (ga, pFrom, pTo);
	  tps_ga_chromosome_update (mutant, pFrom, pTo, cost);
	  *(mutant->Costs + j) = cost;
	  mutant->TotalCost += cost;
      }
}

static TspGaSolutionPtr
tsp_ga_clone_solution (TspGaPopulationPtr ga, TspGaSolutionPtr original)
{
/* cloning a TSP GA solution */
    int j;
    TspGaSolutionPtr clone;
    if (original == NULL)
	return NULL;

    clone = malloc (sizeof (TspGaSolution));
    clone->Cities = original->Cities;
    clone->CitiesFrom = malloc (sizeof (RouteNodePtr) * ga->Cities);
    clone->CitiesTo = malloc (sizeof (RouteNodePtr) * ga->Cities);
    clone->Costs = malloc (sizeof (double) * ga->Cities);
    for (j = 0; j < ga->Cities; j++)
      {
	  *(clone->CitiesFrom + j) = *(original->CitiesFrom + j);
	  *(clone->CitiesTo + j) = *(original->CitiesTo + j);
	  *(clone->Costs + j) = *(original->Costs + j);
      }
    clone->TotalCost = 0.0;
    return clone;
}

static TspGaSolutionPtr
tsp_ga_crossover (sqlite3 * handle, TspGaPopulationPtr ga, int mutation1,
		  int mutation2)
{
/* creating a Crossover solution */
    int j;
    int idx1;
    int idx2;
    TspGaSolutionPtr hybrid;
    TspGaSolutionPtr parent1 = NULL;
    TspGaSolutionPtr parent2 = NULL;

/* randomly choosing two parents */
    tsp_ga_random_solutions (handle, ga, &idx1, &idx2);
    if (idx1 >= 0 && idx1 < ga->Count)
	parent1 = tsp_ga_clone_solution (ga, *(ga->Solutions + idx1));
    if (idx2 >= 0 && idx2 < ga->Count)
	parent2 = tsp_ga_clone_solution (ga, *(ga->Solutions + idx2));
    if (parent1 == NULL || parent2 == NULL)
	goto stop;

    if (mutation1)
	tsp_ga_random_mutation (handle, ga, parent1);
    if (mutation2)
	tsp_ga_random_mutation (handle, ga, parent2);

/* creating an empty hybrid */
    hybrid = malloc (sizeof (TspGaSolution));
    hybrid->Cities = ga->Cities;
    hybrid->CitiesFrom = malloc (sizeof (RouteNodePtr) * ga->Cities);
    hybrid->CitiesTo = malloc (sizeof (RouteNodePtr) * ga->Cities);
    hybrid->Costs = malloc (sizeof (double) * ga->Cities);
    for (j = 0; j < ga->Cities; j++)
      {
	  *(hybrid->CitiesFrom + j) = NULL;
	  *(hybrid->CitiesTo + j) = NULL;
	  *(hybrid->Costs + j) = DBL_MAX;
      }
    hybrid->TotalCost = 0.0;

/* step #1: inheritance from the fist parent */
    tsp_ga_random_interval (handle, ga, &idx1, &idx2);
    if (idx1 < idx2)
      {
	  for (j = idx1; j <= idx2; j++)
	      *(hybrid->CitiesFrom + j) = *(parent1->CitiesFrom + j);
      }
    else
      {
	  for (j = idx2; j <= idx1; j++)
	      *(hybrid->CitiesFrom + j) = *(parent1->CitiesFrom + j);
      }

/* step #2: inheritance from the second parent */
    for (j = 0; j < parent2->Cities; j++)
      {
	  RouteNodePtr p2From = *(parent2->CitiesFrom + j);
	  int k;
	  int found = 0;
	  if (p2From == NULL)
	      continue;
	  for (k = 0; k < hybrid->Cities; k++)
	    {
		RouteNodePtr p1From = *(hybrid->CitiesFrom + k);
		if (p1From == NULL)
		    continue;
		if (p1From == p2From)
		  {
		      /* already present: skipping */
		      found = 1;
		      break;
		  }
	    }
	  if (found)
	      continue;
	  for (k = 0; k < hybrid->Cities; k++)
	    {
		if (*(hybrid->CitiesFrom + k) == NULL
		    && *(hybrid->CitiesTo + k) == NULL
		    && *(hybrid->Costs + k) == DBL_MAX)
		  {
		      /* found an empty slot: inserting */
		      *(hybrid->CitiesFrom + k) = p2From;
		      break;
		  }
	    }
      }
    destroy_tsp_ga_solution (parent1);
    destroy_tsp_ga_solution (parent2);

/* adjusting From/To */
    for (j = 1; j < hybrid->Cities; j++)
      {
	  RouteNodePtr p1From = *(hybrid->CitiesFrom + j);
	  *(hybrid->CitiesTo + j - 1) = p1From;
      }
    *(hybrid->CitiesTo + hybrid->Cities - 1) = *(hybrid->CitiesFrom + 0);

/* retrieving cached costs */
    for (j = 0; j < hybrid->Cities; j++)
      {
	  RouteNodePtr pFrom = *(hybrid->CitiesFrom + j);
	  RouteNodePtr pTo = *(hybrid->CitiesTo + j);
	  double cost = tsp_ga_find_distance (ga, pFrom, pTo);
	  tps_ga_chromosome_update (hybrid, pFrom, pTo, cost);
	  hybrid->TotalCost += cost;
      }
    return hybrid;

  stop:
    if (parent1 != NULL)
	destroy_tsp_ga_solution (parent1);
    if (parent2 != NULL)
	destroy_tsp_ga_solution (parent2);
    return NULL;
}

static void
evalTspGaFitness (TspGaPopulationPtr ga)
{
/* evaluating the comparative fitness of parents and offsprings */
    int j;
    int i;
    int index;
    int already_defined = 0;

    for (j = 0; j < ga->Count; j++)
      {
	  /* evaluating an offsprings */
	  double max_cost = 0.0;
	  TspGaSolutionPtr hybrid = *(ga->Offsprings + j);

	  for (i = 0; i < ga->Count; i++)
	    {
		/* searching the worst parent */
		TspGaSolutionPtr old = *(ga->Solutions + i);
		if (old->TotalCost > max_cost)
		  {
		      max_cost = old->TotalCost;
		      index = i;
		  }
		if (old->TotalCost == hybrid->TotalCost)
		    already_defined = 1;
	    }
	  if (max_cost > hybrid->TotalCost && !already_defined)
	    {
		/* inserting the new hybrid by replacing the worst parent */
		TspGaSolutionPtr kill = *(ga->Solutions + index);
		*(ga->Solutions + index) = hybrid;
		*(ga->Offsprings + j) = NULL;
		destroy_tsp_ga_solution (kill);
	    }
      }
}

static MultiSolutionPtr
tsp_ga_compute_route (sqlite3 * handle, int options, RouteNodePtr origin,
		      RouteNodePtr destination, RoutingPtr graph,
		      RoutingNodesPtr routing)
{
/* computing a route from City to City */
    RoutingMultiDestPtr to = NULL;
    MultiSolutionPtr ms = alloc_multiSolution ();
    ms->From = origin;
    to = malloc (sizeof (RoutingMultiDest));
    ms->MultiTo = to;
    to->CodeNode = graph->NodeCode;
    to->Found = malloc (sizeof (char));
    to->To = malloc (sizeof (RouteNodePtr));
    *(to->Found + 0) = 'N';
    *(to->To + 0) = destination;
    to->Items = 1;
    to->Next = 0;
    if (graph->NodeCode)
      {
	  int len = strlen (destination->Code);
	  to->Ids = NULL;
	  to->Codes = malloc (sizeof (char *));
	  *(to->Codes + 0) = malloc (len + 1);
	  strcpy (*(to->Codes + 0), destination->Code);
      }
    else
      {
	  to->Ids = malloc (sizeof (sqlite3_int64));
	  to->Codes = NULL;
	  *(to->Ids + 0) = destination->Id;
      }

    dijkstra_multi_shortest_path (handle, options, graph, routing, ms);
    return (ms);
}

static void
completing_tsp_ga_solution (sqlite3 * handle, int options, RouteNodePtr origin,
			    RouteNodePtr destination, RoutingPtr graph,
			    RoutingNodesPtr routing, TspTargetsPtr targets,
			    int j)
{
/* completing a TSP GA solution */
    ShortestPathSolutionPtr solution;
    MultiSolutionPtr result =
	tsp_ga_compute_route (handle, options, origin, destination, graph,
			      routing);

    solution = result->First;
    while (solution != NULL)
      {
	  RowSolutionPtr old;
	  ShortestPathSolutionPtr newSolution = alloc_solution ();
	  newSolution->From = origin;
	  newSolution->To = destination;
	  newSolution->TotalCost += solution->TotalCost;
	  targets->TotalCost += solution->TotalCost;
	  newSolution->Geometry = solution->Geometry;
	  solution->Geometry = NULL;
	  if (j < 0)
	      targets->LastSolution = newSolution;
	  else
	      *(targets->Solutions + j) = newSolution;
	  old = solution->First;
	  while (old != NULL)
	    {
		/* inserts an Arc into the Shortest Path solution */
		RowSolutionPtr p = malloc (sizeof (RowSolution));
		p->Arc = old->Arc;
		p->Name = old->Name;
		old->Name = NULL;
		p->Next = NULL;
		if (!(newSolution->First))
		    newSolution->First = p;
		if (newSolution->Last)
		    newSolution->Last->Next = p;
		newSolution->Last = p;
		old = old->Next;
	    }
	  solution = solution->Next;
      }
    delete_multiSolution (result);
}

static void
set_tsp_ga_targets (sqlite3 * handle, int options, RoutingPtr graph,
		    RoutingNodesPtr routing, TspGaSolutionPtr bestSolution,
		    TspTargetsPtr targets)
{
/* preparing TSP GA targets (best solution found) */
    int j;
    RouteNodePtr from;
    RouteNodePtr to;

    for (j = 0; j < targets->Count; j++)
      {
	  from = *(bestSolution->CitiesFrom + j);
	  to = *(bestSolution->CitiesTo + j);
	  completing_tsp_ga_solution (handle, options, from, to,
				      graph, routing, targets, j);
	  *(targets->To + j) = to;
	  *(targets->Found + j) = 'Y';
      }
    /* this is the final City closing the circular path */
    from = *(bestSolution->CitiesFrom + targets->Count);
    to = *(bestSolution->CitiesTo + targets->Count);
    completing_tsp_ga_solution (handle, options, from, to, graph,
				routing, targets, -1);
}

static TspTargetsPtr
build_tsp_ga_solution_targets (int count, RouteNodePtr from)
{
/* creating and initializing the TSP helper struct - final solution */
    int i;
    TspTargetsPtr targets = malloc (sizeof (TspTargets));
    targets->Mode = VROUTE_TSP_SOLUTION;
    targets->TotalCost = 0.0;
    targets->Count = count;
    targets->To = malloc (sizeof (RouteNodePtr *) * targets->Count);
    targets->Found = malloc (sizeof (char) * targets->Count);
    targets->Costs = malloc (sizeof (double) * targets->Count);
    targets->Solutions =
	malloc (sizeof (ShortestPathSolutionPtr) * targets->Count);
    targets->LastSolution = NULL;
    targets->From = from;
    for (i = 0; i < targets->Count; i++)
      {
	  *(targets->To + i) = NULL;
	  *(targets->Found + i) = 'N';
	  *(targets->Costs + i) = DBL_MAX;
	  *(targets->Solutions + i) = NULL;
      }
    return targets;
}

static TspTargetsPtr
tsp_ga_permuted_targets (RouteNodePtr from, RoutingMultiDestPtr multi,
			 int index)
{
/* initializing the TSP helper struct - permuted */
    int i;
    TspTargetsPtr targets = malloc (sizeof (TspTargets));
    targets->Mode = VROUTE_ROUTING_SOLUTION;
    targets->TotalCost = 0.0;
    targets->Count = multi->Items;
    targets->To = malloc (sizeof (RouteNodePtr *) * targets->Count);
    targets->Found = malloc (sizeof (char) * targets->Count);
    targets->Costs = malloc (sizeof (double) * targets->Count);
    targets->Solutions =
	malloc (sizeof (ShortestPathSolutionPtr) * targets->Count);
    targets->LastSolution = NULL;
    if (index < 0)
      {
	  /* no permutation */
	  targets->From = from;
	  for (i = 0; i < targets->Count; i++)
	    {
		*(targets->To + i) = *(multi->To + i);
		*(targets->Found + i) = 'N';
		*(targets->Costs + i) = DBL_MAX;
		*(targets->Solutions + i) = NULL;
	    }
      }
    else
      {
	  /* permuting */
	  targets->From = *(multi->To + index);
	  for (i = 0; i < targets->Count; i++)
	    {
		if (i == index)
		  {
		      *(targets->To + i) = from;
		      *(targets->Found + i) = 'N';
		      *(targets->Costs + i) = DBL_MAX;
		      *(targets->Solutions + i) = NULL;
		  }
		else
		  {
		      *(targets->To + i) = *(multi->To + i);
		      *(targets->Found + i) = 'N';
		      *(targets->Costs + i) = DBL_MAX;
		      *(targets->Solutions + i) = NULL;
		  }
	    }
      }
    return targets;
}

static int
build_tsp_nn_solution (TspGaPopulationPtr ga, TspTargetsPtr targets, int index)
{
/* building a TSP NN solution */
    int j;
    int i;
    RouteNodePtr origin;
    TspGaDistancePtr dist;
    TspGaSubDistancePtr sub;
    RouteNodePtr destination;
    double cost;
    TspGaSolutionPtr solution = malloc (sizeof (TspGaSolution));
    solution->Cities = targets->Count + 1;
    solution->CitiesFrom = malloc (sizeof (RouteNodePtr) * solution->Cities);
    solution->CitiesTo = malloc (sizeof (RouteNodePtr) * solution->Cities);
    solution->Costs = malloc (sizeof (double) * solution->Cities);
    solution->TotalCost = 0.0;

    origin = targets->From;
    for (j = 0; j < targets->Count; j++)
      {
	  /* searching the nearest City */
	  dist = tsp_ga_find_from_distance (ga, origin);
	  if (dist == NULL)
	      return 0;
	  destination = NULL;
	  cost = DBL_MAX;

	  sub = *(dist->Distances + dist->NearestIndex);
	  destination = sub->CityTo;
	  cost = sub->Cost;
	  /* excluding the last City (should be a closed circuit) */
	  if (destination == targets->From)
	      destination = NULL;
	  if (destination != NULL)
	    {
		for (i = 0; i < targets->Count; i++)
		  {
		      /* checking if this City was already reached */
		      RouteNodePtr city = *(targets->To + i);
		      if (city == destination)
			{
			    if (*(targets->Found + i) == 'Y')
				destination = NULL;
			    else
				*(targets->Found + i) = 'Y';
			    break;
			}
		  }
	    }
	  if (destination == NULL)
	    {
		/* searching for an alternative destination */
		double min = DBL_MAX;
		int ind = -1;
		int k;
		for (k = 0; k < dist->Cities; k++)
		  {
		      sub = *(dist->Distances + k);
		      RouteNodePtr city = sub->CityTo;
		      /* excluding the last City (should be a closed circuit) */
		      if (city == targets->From)
			  continue;
		      for (i = 0; i < targets->Count; i++)
			{
			    RouteNodePtr city2 = *(targets->To + i);
			    if (*(targets->Found + i) == 'Y')
				continue;
			    if (city == city2)
			      {
				  if (sub->Cost < min)
				    {
					min = sub->Cost;
					ind = k;
				    }
			      }
			}
		  }
		if (ind >= 0)
		  {
		      sub = *(dist->Distances + ind);
		      destination = sub->CityTo;
		      cost = min;
		      for (i = 0; i < targets->Count; i++)
			{
			    RouteNodePtr city = *(targets->To + i);
			    if (city == destination)
			      {
				  *(targets->Found + i) = 'Y';
				  break;
			      }
			}
		  }
	    }
	  if (destination == NULL)
	      return 0;
	  *(solution->CitiesFrom + j) = origin;
	  *(solution->CitiesTo + j) = destination;
	  *(solution->Costs + j) = cost;
	  solution->TotalCost += cost;
	  origin = destination;
      }

/* returning to FROM so to close the circular path */
    destination = targets->From;
    for (i = 0; i < ga->Cities; i++)
      {
	  TspGaDistancePtr d = *(ga->Distances + i);
	  if (d->CityFrom == origin)
	    {
		int k;
		dist = *(ga->Distances + i);
		for (k = 0; k < dist->Cities; k++)
		  {
		      sub = *(dist->Distances + k);
		      RouteNodePtr city = sub->CityTo;
		      if (city == destination)
			{
			    cost = sub->Cost;
			    *(solution->CitiesFrom + targets->Count) = origin;
			    *(solution->CitiesTo + targets->Count) =
				destination;
			    *(solution->Costs + targets->Count) = cost;
			    solution->TotalCost += cost;
			}
		  }
	    }
      }

/* inserting into the GA population */
    *(ga->Solutions + index) = solution;
    return 1;
}

static int
cmp_nodes_addr (const void *p1, const void *p2)
{
/* compares two nodes  by addr [for QSORT] */
    TspGaDistancePtr pD1 = *((TspGaDistancePtr *) p1);
    TspGaDistancePtr pD2 = *((TspGaDistancePtr *) p2);
    RouteNodePtr pN1 = pD1->CityFrom;
    RouteNodePtr pN2 = pD2->CityFrom;
    if (pN1 == pN2)
	return 0;
    if (pN1 > pN2)
	return 1;
    return -1;
}

static int
cmp_dist_addr (const void *p1, const void *p2)
{
/* compares two nodes  by addr [for QSORT] */
    TspGaSubDistancePtr pD1 = *((TspGaSubDistancePtr *) p1);
    TspGaSubDistancePtr pD2 = *((TspGaSubDistancePtr *) p2);
    RouteNodePtr pN1 = pD1->CityTo;
    RouteNodePtr pN2 = pD2->CityTo;
    if (pN1 == pN2)
	return 0;
    if (pN1 > pN2)
	return 1;
    return -1;
}

static void
tsp_ga_sort_distances (TspGaPopulationPtr ga)
{
/* sorting Distances/Costs by Node addr */
    int i;
    qsort (ga->Distances, ga->Cities, sizeof (RouteNodePtr), cmp_nodes_addr);
    for (i = 0; i < ga->Cities; i++)
      {
	  TspGaDistancePtr dist = *(ga->Distances + i);
	  qsort (dist->Distances, dist->Cities, sizeof (TspGaSubDistancePtr),
		 cmp_dist_addr);
      }
    for (i = 0; i < ga->Cities; i++)
      {
	  int k;
	  int index = -1;
	  double min = DBL_MAX;
	  TspGaDistancePtr dist = *(ga->Distances + i);
	  for (k = 0; k < dist->Cities; k++)
	    {
		TspGaSubDistancePtr sub = *(dist->Distances + k);
		if (sub->Cost < min)
		  {
		      min = sub->Cost;
		      index = k;
		  }
	    }
	  if (index >= 0)
	      dist->NearestIndex = index;
      }
}

static void
tsp_ga_solve (sqlite3 * handle, int options, RoutingPtr graph,
	      RoutingNodesPtr routing, MultiSolutionPtr multiSolution)
{
/* computing a Dijkstra TSP GA Solution */
    int i;
    int j;
    double min;
    TspGaSolutionPtr bestSolution;
    int count = 0;
    int max_iterations = VROUTE_TSP_GA_MAX_ITERATIONS;
    TspGaPopulationPtr ga = NULL;
    RoutingMultiDestPtr multi;
    TspTargetsPtr targets;
    TspGaDistancePtr dist;

    if (multiSolution == NULL)
	return;
    multi = multiSolution->MultiTo;
    if (multi == NULL)
	return;

/* initialinzing the TSP GA helper struct */
    ga = build_tsp_ga_population (multi->Items + 1);

    for (i = -1; i < multi->Items; i++)
      {
	  /* determining all City-to-City distances (costs) */
	  targets = tsp_ga_permuted_targets (multiSolution->From, multi, i);
	  for (j = 0; j < targets->Count; j++)
	    {
		/* checking for undefined targets */
		if (*(targets->To + j) == NULL)
		  {
		      int k;
		      for (k = 0; k < targets->Count; k++)
			{
			    /* maskinkg unreachable targets */
			    *(targets->Found + k) = 'Y';
			}
		      build_tsp_illegal_solution (multiSolution, targets);
		      destroy_tsp_targets (targets);
		      goto invalid;
		  }
	    }
	  dijkstra_targets_solve (routing, targets);
	  for (j = 0; j < targets->Count; j++)
	    {
		/* checking for unreachable targets */
		if (*(targets->Found + j) != 'Y')
		  {
		      build_tsp_illegal_solution (multiSolution, targets);
		      destroy_tsp_targets (targets);
		      goto invalid;
		  }
	    }
	  /* inserting the distances/costs into the helper struct */
	  dist = alloc_tsp_ga_distances (targets);
	  *(ga->Distances + i + 1) = dist;
	  destroy_tsp_targets (targets);
      }
    tsp_ga_sort_distances (ga);

    for (i = -1; i < multi->Items; i++)
      {
	  /* initializing GA using permuted NN solutions */
	  int ret;
	  targets = tsp_ga_permuted_targets (multiSolution->From, multi, i);
	  ret = build_tsp_nn_solution (ga, targets, i + 1);
	  destroy_tsp_targets (targets);
	  if (!ret)
	      goto invalid;
      }

    while (max_iterations >= 0)
      {
	  /* sexual reproduction and darwinian selection */
	  for (i = 0; i < ga->Count; i++)
	    {
		/* Genetic loop - with mutations */
		TspGaSolutionPtr hybrid;
		int mutation1 = 0;
		int mutation2 = 0;
		count++;
		if (count % 13 == 0)
		  {
		      /* introducing a random mutation on parent #1 */
		      mutation1 = 1;
		  }
		if (count % 16 == 0)
		  {
		      /* introducing a random mutation on parent #2 */
		      mutation2 = 1;
		  }
		hybrid = tsp_ga_crossover (handle, ga, mutation1, mutation2);
		*(ga->Offsprings + i) = hybrid;
	    }
	  evalTspGaFitness (ga);
	  free_tsp_ga_offsprings (ga);
	  max_iterations--;
      }

/* building the TSP GA solution */
    min = DBL_MAX;
    bestSolution = NULL;
    for (i = 0; i < ga->Count; i++)
      {
	  /* searching the best solution */
	  TspGaSolutionPtr old = *(ga->Solutions + i);
	  if (old == NULL)
	      continue;
	  if (old->TotalCost < min)
	    {
		min = old->TotalCost;
		bestSolution = old;
	    }
      }
    if (bestSolution != NULL)
      {
	  targets =
	      build_tsp_ga_solution_targets (multiSolution->MultiTo->Items,
					     multiSolution->From);
	  set_tsp_ga_targets (handle, options, graph, routing, bestSolution,
			      targets);
	  build_tsp_solution (multiSolution, targets);
	  destroy_tsp_targets (targets);
      }
    destroy_tsp_ga_population (ga);
    return;

  invalid:
    destroy_tsp_ga_population (ga);
}

static void
network_free (RoutingPtr p)
{
/* memory cleanup; freeing any allocation for the network struct */
    RouteNodePtr pN;
    int i;
................................................................................
		  {
		      tsp_nn_solve (net->db, net->currentOptions, net->graph,
				    net->routing, cursor->pVtab->multiSolution);
		      cursor->pVtab->multiSolution->CurrentRowId = 0;
		      cursor->pVtab->multiSolution->CurrentRow =
			  cursor->pVtab->multiSolution->FirstRow;
		  }
	    }
	  else if (net->currentRequest == VROUTE_TSP_GA)
	    {
		cursor->pVtab->multiSolution->Mode = VROUTE_TSP_SOLUTION;
		if (net->currentAlgorithm == VROUTE_DIJKSTRA_ALGORITHM)
		  {
		      tsp_ga_solve (net->db, net->currentOptions, net->graph,
				    net->routing, cursor->pVtab->multiSolution);
		      cursor->pVtab->multiSolution->CurrentRowId = 0;
		      cursor->pVtab->multiSolution->CurrentRow =
			  cursor->pVtab->multiSolution->FirstRow;
		  }
	    }
	  else
	    {
		cursor->pVtab->multiSolution->Mode = VROUTE_ROUTING_SOLUTION;
		if (net->currentAlgorithm == VROUTE_A_STAR_ALGORITHM)
		    astar_solve (net->db, net->currentOptions, net->graph,
				 net->routing, cursor->pVtab->multiSolution);
................................................................................
					   SQLITE_TRANSIENT);
		  }
		else if (column == 1)
		  {
		      /* the current Request type */
		      if (net->currentRequest == VROUTE_TSP_NN)
			  algorithm = "TSP NN";
		      else if (net->currentRequest == VROUTE_TSP_GA)
			  algorithm = "TSP GA";
		      else
			  algorithm = "Shortest Path";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		else if (column == 2)
................................................................................
				   cursor->pVtab->currentDelimiter);
		      sqlite3_result_text (pContext, delimiter,
					   strlen (delimiter),
					   SQLITE_TRANSIENT);
		  }
		else
		    sqlite3_result_null (pContext);
		return SQLITE_OK;
	    }
	  if (row->Undefined != NULL)
	    {
		/* special case: there is an undefined destination */
		if (column == 0)
		  {
		      /* the currently used Algorithm */
		      if (net->currentAlgorithm == VROUTE_A_STAR_ALGORITHM)
			  algorithm = "A*";
		      else
			  algorithm = "Dijkstra";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		if (column == 1)
		  {
		      /* the current Request type */
		      if (net->currentRequest == VROUTE_TSP_NN)
			  algorithm = "TSP NN";
		      else if (net->currentRequest == VROUTE_TSP_GA)
			  algorithm = "TSP GA";
		      else
			  algorithm = "Shortest Path";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		if (column == 2)
		  {
		      /* the currently set Options */
		      if (net->currentOptions == VROUTE_SHORTEST_PATH_SIMPLE)
			  algorithm = "Simple";
		      else if (net->currentOptions ==
			       VROUTE_SHORTEST_PATH_NO_ARCS)
			  algorithm = "No Arcs";
		      else if (net->currentOptions ==
			       VROUTE_SHORTEST_PATH_NO_GEOMS)
			  algorithm = "No Geometries";
		      else
			  algorithm = "Full";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		if (column == 3)
		  {
		      /* the currently set delimiter char */
		      if (isprint (cursor->pVtab->currentDelimiter))
			  sprintf (delimiter, "%c [dec=%d, hex=%02x]",
				   cursor->pVtab->currentDelimiter,
				   cursor->pVtab->currentDelimiter,
				   cursor->pVtab->currentDelimiter);
		      else
			  sprintf (delimiter, "[dec=%d, hex=%02x]",
				   cursor->pVtab->currentDelimiter,
				   cursor->pVtab->currentDelimiter);
		      sqlite3_result_text (pContext, delimiter,
					   strlen (delimiter),
					   SQLITE_TRANSIENT);
		  }
		if (column == 4)
		  {
		      /* the RouteNum column */
		      sqlite3_result_int (pContext, row->RouteNum);
		  }
		if (column == 5)
		  {
		      /* the RouteRow column */
		      sqlite3_result_int (pContext, row->RouteRow);
		  }
		if (column == 6)
		  {
		      /* role of this row */
		      if (row->To != NULL)
			  role = "Unreachable NodeTo";
		      else
			  role = "Undefined NodeTo";
		      sqlite3_result_text (pContext, role, strlen (role),
					   SQLITE_TRANSIENT);
		  }
		if (column == 7)
		  {
		      /* the ArcRowId column */
		      sqlite3_result_null (pContext);
		  }
		if (column == 8)
		  {
		      /* the NodeFrom column */
		      if (row->From == NULL)
			{
			    sqlite3_result_text (pContext,
						 row->Undefined,
						 strlen (row->Undefined),
						 SQLITE_STATIC);
			}
		      else
			{
			    if (node_code)
				sqlite3_result_text (pContext,
						     row->From->Code,
						     strlen (row->From->Code),
						     SQLITE_STATIC);
			    else
				sqlite3_result_int64 (pContext, row->From->Id);
			}
		  }
		if (column == 9)
		  {
		      /* the NodeTo column */
		      sqlite3_result_text (pContext,
					   row->Undefined,
					   strlen (row->Undefined),
					   SQLITE_STATIC);
		  }
		if (column == 10)
		  {
		      /* the Cost column */
		      sqlite3_result_null (pContext);
		  }
		if (column == 11)
		  {
		      /* the Geometry column */
		      sqlite3_result_null (pContext);
		  }
		if (column == 12)
		  {
		      /* the [optional] Name column */
		      sqlite3_result_null (pContext);
		  }
		return SQLITE_OK;
	    }
	  if (row->linkRef == NULL)
	    {
		/* special case: this one is the solution summary */
		if (column == 0)
		  {
................................................................................
					   SQLITE_TRANSIENT);
		  }
		if (column == 1)
		  {
		      /* the current Request type */
		      if (net->currentRequest == VROUTE_TSP_NN)
			  algorithm = "TSP NN";
		      else if (net->currentRequest == VROUTE_TSP_GA)
			  algorithm = "TSP GA";
		      else
			  algorithm = "Shortest Path";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		if (column == 2)
................................................................................
		      sqlite3_result_int (pContext, row->RouteRow);
		  }
		if (column == 6)
		  {
		      /* role of this row */
		      if (cursor->pVtab->multiSolution->Mode ==
			  VROUTE_TSP_SOLUTION && row->RouteNum == 0)


			  role = "TSP Solution";
		      else
			{
			    if (row->From == row->To)
				role = "Unreachable NodeTo";

			    else
				role = "Route";
			}
		      sqlite3_result_text (pContext, role, strlen (role),
					   SQLITE_TRANSIENT);
		  }
		if (row->From == NULL || row->To == NULL)
		  {
		      /* empty [uninitialized] solution */
		      if (column > 0)
................................................................................
					       SQLITE_STATIC);
		      else
			  sqlite3_result_int64 (pContext, row->To->Id);
		  }
		if (column == 10)
		  {
		      /* the Cost column */
		      if (row->RouteNum != 0 && (row->From == row->To))
			  sqlite3_result_null (pContext);
		      else
			  sqlite3_result_double (pContext, row->TotalCost);
		  }
		if (column == 11)
		  {
		      /* the Geometry column */
		      if (!(row->Geometry))
			  sqlite3_result_null (pContext);
		      else
................................................................................
					   SQLITE_TRANSIENT);
		  }
		if (column == 1)
		  {
		      /* the current Request type */
		      if (net->currentRequest == VROUTE_TSP_NN)
			  algorithm = "TSP NN";
		      else if (net->currentRequest == VROUTE_TSP_GA)
			  algorithm = "TSP GA";
		      else
			  algorithm = "Shortest Path";
		      sqlite3_result_text (pContext, algorithm,
					   strlen (algorithm),
					   SQLITE_TRANSIENT);
		  }
		if (column == 2)
................................................................................
			    const unsigned char *request =
				sqlite3_value_text (argv[3]);
			    if (strcasecmp ((char *) request, "TSP") == 0)
				p_vtab->currentRequest = VROUTE_TSP_NN;
			    else if (strcasecmp
				     ((char *) request, "TSP NN") == 0)
				p_vtab->currentRequest = VROUTE_TSP_NN;
			    else if (strcasecmp
				     ((char *) request, "TSP GA") == 0)
				p_vtab->currentRequest = VROUTE_TSP_GA;
			    else if (strcasecmp
				     ((char *) request, "SHORTEST PATH") == 0)
				p_vtab->currentRequest = VROUTE_SHORTEST_PATH;
			}
		      if (sqlite3_value_type (argv[4]) == SQLITE_TEXT)
			{
			    const unsigned char *options =

	  *edge_ids = ids;
	  *ids_count = nedges;
	  ret = 1;
	  rtfree (ctx, edgeids);
      }
    return ret;
}
















































































































GAIATOPO_DECLARE int
gaiaTopoGeo_AddPolygon (GaiaTopologyAccessorPtr accessor, gaiaPolygonPtr pg,
			double tolerance, sqlite3_int64 ** face_ids,
			int *ids_count)
{
/* RTT wrapper - AddPolygon */
................................................................................
      }
    return result;
}

TOPOLOGY_PRIVATE int
auxtopo_insert_into_topology (GaiaTopologyAccessorPtr accessor,
			      gaiaGeomCollPtr geom, double tolerance,
			      int line_max_points, double max_length)
{
/* processing all individual geometry items */
    gaiaPointPtr pt;
    gaiaLinestringPtr ln;
    gaiaGeomCollPtr g;
    gaiaGeomCollPtr split = NULL;
    gaiaGeomCollPtr pg_rings;
................................................................................
	  else
	      g = geom;
      }
    ln = g->FirstLinestring;
    while (ln != NULL)
      {
	  /* looping on Linestrings items */





	  if (gaiaTopoGeo_AddLineString
	      (accessor, ln, tolerance, &ids, &ids_count) == 0)

	      return 0;
	  if (ids != NULL)
	      free (ids);
	  ln = ln->Next;
      }
    if (split != NULL)
	gaiaFreeGeomColl (split);
................................................................................
    pg_rings = do_linearize (geom);
    if (pg_rings != NULL)
      {
	  if (line_max_points <= 0 && max_length <= 0.0)
	      g = pg_rings;
	  else
	    {
		/* subdividng Linestrings */
		split =
		    gaiaTopoGeo_SubdivideLines (pg_rings, line_max_points,
						max_length);
		if (split != NULL)
		    g = split;
		else
		    g = pg_rings;
	    }
	  ln = g->FirstLinestring;
	  while (ln != NULL)
	    {
		/* looping on Linestrings items */





		if (gaiaTopoGeo_AddLineString
		    (accessor, ln, tolerance, &ids, &ids_count) == 0)

		    return 0;
		if (ids != NULL)
		    free (ids);
		ln = ln->Next;
	    }
	  gaiaFreeGeomColl (pg_rings);
	  if (split != NULL)
................................................................................
		      gaiaGeomCollPtr geom =
			  gaiaFromSpatiaLiteBlobWkbEx (blob, blob_sz, gpkg_mode,
						       gpkg_amphibious);
		      if (geom != NULL)
			{
			    if (!auxtopo_insert_into_topology
				(accessor, geom, tolerance, line_max_points,
				 max_length))
			      {
				  gaiaFreeGeomColl (geom);
				  goto error;
			      }
			    gaiaFreeGeomColl (geom);
			}
		      else
................................................................................
		    sqlite3_mprintf ("TopoGeo_FromGeoTable error: \"%s\"",
				     sqlite3_errmsg (topo->db_handle));
		gaiatopo_set_last_error_msg (accessor, msg);
		sqlite3_free (msg);
		goto error;
	    }
      }


























































































































    sqlite3_finalize (stmt);
    return 1;

  error:
    if (stmt != NULL)
	sqlite3_finalize (stmt);
................................................................................

static int
do_FromGeoTableExtended_block (GaiaTopologyAccessorPtr accessor,
			       sqlite3_stmt * stmt, sqlite3_stmt * stmt_dustbin,
			       double tolerance, int line_max_points,
			       double max_length, sqlite3_int64 start,
			       sqlite3_int64 * last, sqlite3_int64 * invalid,
			       int *dustbin_count, sqlite3_int64 * dustbin_row)
{
/* attempting to import a whole block of input features */
    struct gaia_topology *topo = (struct gaia_topology *) accessor;
    int ret;
    int gpkg_amphibious = 0;
    int gpkg_mode = 0;
    int totcnt = 0;
................................................................................
			  gaiaFromSpatiaLiteBlobWkbEx (blob, blob_sz, gpkg_mode,
						       gpkg_amphibious);
		      if (geom != NULL)
			{
			    gaiatopo_reset_last_error_msg (accessor);
			    if (!auxtopo_insert_into_topology
				(accessor, geom, tolerance, line_max_points,
				 max_length))
			      {
				  char *msg;
				  const char *rt_msg =
				      gaiaGetRtTopoErrorMsg (topo->cache);
				  if (rt_msg == NULL)
				      msg =
					  sqlite3_mprintf
................................................................................
    while (1)
      {
	  /* main loop: attempting to import a block of features */
	  ret =
	      do_FromGeoTableExtended_block (accessor, stmt, stmt_dustbin,
					     tolerance, line_max_points,
					     max_length, start, &last, &invalid,
					     &dustbin_count, &dustbin_row);


















































































































	  if (ret < 0)		/* some unexpected error occurred */
	      goto error;
	  if (ret > 1)
	    {
		/* eof */
		break;
	    }
................................................................................
	    {
		/* found a failing feature; recovering */
		ret =
		    do_FromGeoTableExtended_block (accessor, stmt, stmt_dustbin,
						   tolerance, line_max_points,
						   max_length, start, &last,
						   &invalid, &dustbin_count,
						   &dustbin_row);
		if (ret != 1)
		    goto error;
		start = invalid;
		invalid = -1;
		dustbin_row = -1;
		continue;
	    }

	  *edge_ids = ids;
	  *ids_count = nedges;
	  ret = 1;
	  rtfree (ctx, edgeids);
      }
    return ret;
}

GAIATOPO_DECLARE int
gaiaTopoGeo_AddLineStringNoFace (GaiaTopologyAccessorPtr accessor,
			   gaiaLinestringPtr ln, double tolerance,
			   sqlite3_int64 ** edge_ids, int *ids_count)
{
/* RTT wrapper - AddLinestring NO FACE */
    const RTCTX *ctx = NULL;
    struct splite_internal_cache *cache = NULL;
    int ret = 0;
    RTT_ELEMID *edgeids;
    int nedges;
    int i;
    sqlite3_int64 *ids;
    RTLINE *rt_line;
    struct gaia_topology *topo = (struct gaia_topology *) accessor;
    if (topo == NULL)
	return 0;

    cache = (struct splite_internal_cache *) topo->cache;
    if (cache == NULL)
	return 0;
    if (cache->magic1 != SPATIALITE_CACHE_MAGIC1
	|| cache->magic2 != SPATIALITE_CACHE_MAGIC2)
	return 0;
    ctx = cache->RTTOPO_handle;
    if (ctx == NULL)
	return 0;

    rt_line =
	gaia_convert_linestring_to_rtline (ctx, ln, topo->srid, topo->has_z);

    gaiaResetRtTopoMsg (cache);
    edgeids =
	rtt_AddLineNoFace ((RTT_TOPOLOGY *) (topo->rtt_topology), rt_line, tolerance,
		     &nedges);

    rtline_free (ctx, rt_line);
    if (edgeids != NULL)
      {
	  ids = malloc (sizeof (sqlite3_int64) * nedges);
	  for (i = 0; i < nedges; i++)
	      ids[i] = edgeids[i];
	  *edge_ids = ids;
	  *ids_count = nedges;
	  ret = 1;
	  rtfree (ctx, edgeids);
      }
    return ret;
}

GAIATOPO_DECLARE int
gaiaTopoGeo_Polygonize (GaiaTopologyAccessorPtr accessor)
{
/* RTT wrapper - Determine and register all topology faces */
    const RTCTX *ctx = NULL;
    struct splite_internal_cache *cache = NULL;
    struct gaia_topology *topo = (struct gaia_topology *) accessor;
    if (topo == NULL)
	return 0;

    cache = (struct splite_internal_cache *) topo->cache;
    if (cache == NULL)
	return 0;
    if (cache->magic1 != SPATIALITE_CACHE_MAGIC1
	|| cache->magic2 != SPATIALITE_CACHE_MAGIC2)
	return 0;
    ctx = cache->RTTOPO_handle;
    if (ctx == NULL)
	return 0;

    gaiaResetRtTopoMsg (cache);
    rtt_Polygonize ((RTT_TOPOLOGY *) (topo->rtt_topology));
    return 1;
}

GAIATOPO_DECLARE gaiaGeomCollPtr
gaiaTopoSnap (GaiaTopologyAccessorPtr accessor, gaiaGeomCollPtr geom, double tolerance, int iterate, int remove_vertices)
{
/* RTT wrapper - TopoSnap */
    const RTCTX *ctx = NULL;
    struct splite_internal_cache *cache = NULL;
    RTGEOM *input = NULL;
    RTGEOM *result = NULL;
    gaiaGeomCollPtr output;
    struct gaia_topology *topo = (struct gaia_topology *) accessor;
    if (topo == NULL)
	return 0;

    cache = (struct splite_internal_cache *) topo->cache;
    if (cache == NULL)
	return NULL;
    if (cache->magic1 != SPATIALITE_CACHE_MAGIC1
	|| cache->magic2 != SPATIALITE_CACHE_MAGIC2)
	return NULL;
    ctx = cache->RTTOPO_handle;
    if (ctx == NULL)
	return NULL;
    if (!geom)
	return NULL;

    result = rtt_tpsnap ((RTT_TOPOLOGY *) (topo->rtt_topology), input, tolerance, iterate, remove_vertices);
    if (result == NULL)
	return NULL;

/* converting the result as a Gaia Geometry */
	output = fromRTGeom (ctx, result, geom->DimensionModel, geom->DeclaredType);
	output->Srid = geom->Srid;
    rtgeom_free (ctx, result);
    return geom;
}

GAIATOPO_DECLARE int
gaiaTopoGeo_AddPolygon (GaiaTopologyAccessorPtr accessor, gaiaPolygonPtr pg,
			double tolerance, sqlite3_int64 ** face_ids,
			int *ids_count)
{
/* RTT wrapper - AddPolygon */
................................................................................
      }
    return result;
}

TOPOLOGY_PRIVATE int
auxtopo_insert_into_topology (GaiaTopologyAccessorPtr accessor,
			      gaiaGeomCollPtr geom, double tolerance,
			      int line_max_points, double max_length, int mode)
{
/* processing all individual geometry items */
    gaiaPointPtr pt;
    gaiaLinestringPtr ln;
    gaiaGeomCollPtr g;
    gaiaGeomCollPtr split = NULL;
    gaiaGeomCollPtr pg_rings;
................................................................................
	  else
	      g = geom;
      }
    ln = g->FirstLinestring;
    while (ln != NULL)
      {
	  /* looping on Linestrings items */
	  int ret;
	  if (mode == GAIA_MODE_TOPO_NO_FACE)
	  ret =gaiaTopoGeo_AddLineStringNoFace
	      (accessor, ln, tolerance, &ids, &ids_count);
	  else
	  ret = gaiaTopoGeo_AddLineString
	      (accessor, ln, tolerance, &ids, &ids_count);
	  if (ret == 0)
	      return 0;
	  if (ids != NULL)
	      free (ids);
	  ln = ln->Next;
      }
    if (split != NULL)
	gaiaFreeGeomColl (split);
................................................................................
    pg_rings = do_linearize (geom);
    if (pg_rings != NULL)
      {
	  if (line_max_points <= 0 && max_length <= 0.0)
	      g = pg_rings;
	  else
	    {
		/* subdividing Linestrings */
		split =
		    gaiaTopoGeo_SubdivideLines (pg_rings, line_max_points,
						max_length);
		if (split != NULL)
		    g = split;
		else
		    g = pg_rings;
	    }
	  ln = g->FirstLinestring;
	  while (ln != NULL)
	    {
		/* looping on Linestrings items */
		int ret;
		if (mode == GAIA_MODE_TOPO_NO_FACE)
		ret = gaiaTopoGeo_AddLineStringNoFace
		    (accessor, ln, tolerance, &ids, &ids_count);
		else
		ret = gaiaTopoGeo_AddLineString
		    (accessor, ln, tolerance, &ids, &ids_count);
		if (ret == 0)
		    return 0;
		if (ids != NULL)
		    free (ids);
		ln = ln->Next;
	    }
	  gaiaFreeGeomColl (pg_rings);
	  if (split != NULL)
................................................................................
		      gaiaGeomCollPtr geom =
			  gaiaFromSpatiaLiteBlobWkbEx (blob, blob_sz, gpkg_mode,
						       gpkg_amphibious);
		      if (geom != NULL)
			{
			    if (!auxtopo_insert_into_topology
				(accessor, geom, tolerance, line_max_points,
				 max_length, GAIA_MODE_TOPO_FACE))
			      {
				  gaiaFreeGeomColl (geom);
				  goto error;
			      }
			    gaiaFreeGeomColl (geom);
			}
		      else
................................................................................
		    sqlite3_mprintf ("TopoGeo_FromGeoTable error: \"%s\"",
				     sqlite3_errmsg (topo->db_handle));
		gaiatopo_set_last_error_msg (accessor, msg);
		sqlite3_free (msg);
		goto error;
	    }
      }

    sqlite3_finalize (stmt);
    return 1;

  error:
    if (stmt != NULL)
	sqlite3_finalize (stmt);
    return 0;
}

GAIATOPO_DECLARE int
gaiaTopoGeo_FromGeoTableNoFace (GaiaTopologyAccessorPtr accessor,
			  const char *db_prefix, const char *table,
			  const char *column, double tolerance,
			  int line_max_points, double max_length)
{
/* attempting to import a whole GeoTable into a Topology-Geometry
/  without determining generated faces */
    struct gaia_topology *topo = (struct gaia_topology *) accessor;
    sqlite3_stmt *stmt = NULL;
    int ret;
    char *sql;
    char *xprefix;
    char *xtable;
    char *xcolumn;
    int gpkg_amphibious = 0;
    int gpkg_mode = 0;

    if (topo == NULL)
	return 0;
    if (topo->cache != NULL)
      {
	  struct splite_internal_cache *cache =
	      (struct splite_internal_cache *) (topo->cache);
	  gpkg_amphibious = cache->gpkg_amphibious_mode;
	  gpkg_mode = cache->gpkg_mode;
      }

/* building the SQL statement */
    xprefix = gaiaDoubleQuotedSql (db_prefix);
    xtable = gaiaDoubleQuotedSql (table);
    xcolumn = gaiaDoubleQuotedSql (column);
    sql =
	sqlite3_mprintf ("SELECT \"%s\" FROM \"%s\".\"%s\"", xcolumn,
			 xprefix, xtable);
    free (xprefix);
    free (xtable);
    free (xcolumn);
    ret = sqlite3_prepare_v2 (topo->db_handle, sql, strlen (sql), &stmt, NULL);
    sqlite3_free (sql);
    if (ret != SQLITE_OK)
      {
	  char *msg = sqlite3_mprintf ("TopoGeo_FromGeoTableNoFace error: \"%s\"",
				       sqlite3_errmsg (topo->db_handle));
	  gaiatopo_set_last_error_msg (accessor, msg);
	  sqlite3_free (msg);
	  goto error;
      }

/* setting up the prepared statement */
    sqlite3_reset (stmt);
    sqlite3_clear_bindings (stmt);

    while (1)
      {
	  /* scrolling the result set rows */
	  ret = sqlite3_step (stmt);
	  if (ret == SQLITE_DONE)
	      break;		/* end of result set */
	  if (ret == SQLITE_ROW)
	    {
		if (sqlite3_column_type (stmt, 0) == SQLITE_NULL)
		    continue;
		if (sqlite3_column_type (stmt, 0) == SQLITE_BLOB)
		  {
		      const unsigned char *blob = sqlite3_column_blob (stmt, 0);
		      int blob_sz = sqlite3_column_bytes (stmt, 0);
		      gaiaGeomCollPtr geom =
			  gaiaFromSpatiaLiteBlobWkbEx (blob, blob_sz, gpkg_mode,
						       gpkg_amphibious);
		      if (geom != NULL)
			{
			    if (!auxtopo_insert_into_topology
				(accessor, geom, tolerance, line_max_points,
				 max_length, GAIA_MODE_TOPO_NO_FACE))
			      {
				  gaiaFreeGeomColl (geom);
				  goto error;
			      }
			    gaiaFreeGeomColl (geom);
			}
		      else
			{
			    char *msg =
				sqlite3_mprintf
				("TopoGeo_FromGeoTableNoFace error: Invalid Geometry");
			    gaiatopo_set_last_error_msg (accessor, msg);
			    sqlite3_free (msg);
			    goto error;
			}
		  }
		else
		  {
		      char *msg =
			  sqlite3_mprintf
			  ("TopoGeo_FromGeoTableNoFace error: not a BLOB value");
		      gaiatopo_set_last_error_msg (accessor, msg);
		      sqlite3_free (msg);
		      goto error;
		  }
	    }
	  else
	    {
		char *msg =
		    sqlite3_mprintf ("TopoGeo_FromGeoTableNoFace error: \"%s\"",
				     sqlite3_errmsg (topo->db_handle));
		gaiatopo_set_last_error_msg (accessor, msg);
		sqlite3_free (msg);
		goto error;
	    }
      }

    sqlite3_finalize (stmt);
    return 1;

  error:
    if (stmt != NULL)
	sqlite3_finalize (stmt);
................................................................................

static int
do_FromGeoTableExtended_block (GaiaTopologyAccessorPtr accessor,
			       sqlite3_stmt * stmt, sqlite3_stmt * stmt_dustbin,
			       double tolerance, int line_max_points,
			       double max_length, sqlite3_int64 start,
			       sqlite3_int64 * last, sqlite3_int64 * invalid,
			       int *dustbin_count, sqlite3_int64 * dustbin_row, int mode)
{
/* attempting to import a whole block of input features */
    struct gaia_topology *topo = (struct gaia_topology *) accessor;
    int ret;
    int gpkg_amphibious = 0;
    int gpkg_mode = 0;
    int totcnt = 0;
................................................................................
			  gaiaFromSpatiaLiteBlobWkbEx (blob, blob_sz, gpkg_mode,
						       gpkg_amphibious);
		      if (geom != NULL)
			{
			    gaiatopo_reset_last_error_msg (accessor);
			    if (!auxtopo_insert_into_topology
				(accessor, geom, tolerance, line_max_points,
				 max_length, mode))
			      {
				  char *msg;
				  const char *rt_msg =
				      gaiaGetRtTopoErrorMsg (topo->cache);
				  if (rt_msg == NULL)
				      msg =
					  sqlite3_mprintf
................................................................................
    while (1)
      {
	  /* main loop: attempting to import a block of features */
	  ret =
	      do_FromGeoTableExtended_block (accessor, stmt, stmt_dustbin,
					     tolerance, line_max_points,
					     max_length, start, &last, &invalid,
					     &dustbin_count, &dustbin_row, GAIA_MODE_TOPO_FACE);
	  if (ret < 0)		/* some unexpected error occurred */
	      goto error;
	  if (ret > 1)
	    {
		/* eof */
		break;
	    }
	  if (ret == 0)
	    {
		/* found a failing feature; recovering */
		ret =
		    do_FromGeoTableExtended_block (accessor, stmt, stmt_dustbin,
						   tolerance, line_max_points,
						   max_length, start, &last,
						   &invalid, &dustbin_count,
						   &dustbin_row, GAIA_MODE_TOPO_FACE);
		if (ret != 1)
		    goto error;
		start = invalid;
		invalid = -1;
		dustbin_row = -1;
		continue;
	    }
	  start = last;
	  invalid = -1;
	  dustbin_row = -1;
      }

    sqlite3_finalize (stmt);
    sqlite3_finalize (stmt_dustbin);
    sqlite3_finalize (stmt_retry);
    return dustbin_count;

  error:
    if (stmt != NULL)
	sqlite3_finalize (stmt);
    if (stmt_dustbin != NULL)
	sqlite3_finalize (stmt_dustbin);
    return -1;
}

GAIATOPO_DECLARE int
gaiaTopoGeo_FromGeoTableNoFaceExtended (GaiaTopologyAccessorPtr accessor,
				  const char *sql_in, const char *sql_out,
				  const char *sql_in2, double tolerance,
				  int line_max_points, double max_length)
{
/* attempting to import a whole GeoTable into a Topology-Geometry 
/  without determining generated faces - Extended mode */
    struct gaia_topology *topo = (struct gaia_topology *) accessor;
    sqlite3_stmt *stmt = NULL;
    sqlite3_stmt *stmt_dustbin = NULL;
    sqlite3_stmt *stmt_retry = NULL;
    int ret;
    int dustbin_count = 0;
    sqlite3_int64 start = -1;
    sqlite3_int64 last;
    sqlite3_int64 invalid = -1;
    sqlite3_int64 dustbin_row = -1;

    if (topo == NULL)
	return 0;
    if (sql_in == NULL)
	return 0;
    if (sql_out == NULL)
	return 0;

/* building the SQL statement */
    ret =
	sqlite3_prepare_v2 (topo->db_handle, sql_in, strlen (sql_in), &stmt,
			    NULL);
    if (ret != SQLITE_OK)
      {
	  char *msg = sqlite3_mprintf ("TopoGeo_FromGeoTableNoFaceExt error: \"%s\"",
				       sqlite3_errmsg (topo->db_handle));
	  gaiatopo_set_last_error_msg (accessor, msg);
	  sqlite3_free (msg);
	  goto error;
      }

/* building the SQL dustbin statement */
    ret =
	sqlite3_prepare_v2 (topo->db_handle, sql_out, strlen (sql_out),
			    &stmt_dustbin, NULL);
    if (ret != SQLITE_OK)
      {
	  char *msg = sqlite3_mprintf ("TopoGeo_FromGeoTableNoFaceExt error: \"%s\"",
				       sqlite3_errmsg (topo->db_handle));
	  gaiatopo_set_last_error_msg (accessor, msg);
	  sqlite3_free (msg);
	  goto error;
      }

/* building the SQL retry statement */
    ret =
	sqlite3_prepare_v2 (topo->db_handle, sql_in2, strlen (sql_in2),
			    &stmt_retry, NULL);
    if (ret != SQLITE_OK)
      {
	  char *msg = sqlite3_mprintf ("TopoGeo_FromGeoTableNoFaceExt error: \"%s\"",
				       sqlite3_errmsg (topo->db_handle));
	  gaiatopo_set_last_error_msg (accessor, msg);
	  sqlite3_free (msg);
	  goto error;
      }

    while (1)
      {
	  /* main loop: attempting to import a block of features */
	  ret =
	      do_FromGeoTableExtended_block (accessor, stmt, stmt_dustbin,
					     tolerance, line_max_points,
					     max_length, start, &last, &invalid,
					     &dustbin_count, &dustbin_row, GAIA_MODE_TOPO_NO_FACE);
	  if (ret < 0)		/* some unexpected error occurred */
	      goto error;
	  if (ret > 1)
	    {
		/* eof */
		break;
	    }
................................................................................
	    {
		/* found a failing feature; recovering */
		ret =
		    do_FromGeoTableExtended_block (accessor, stmt, stmt_dustbin,
						   tolerance, line_max_points,
						   max_length, start, &last,
						   &invalid, &dustbin_count,
						   &dustbin_row, GAIA_MODE_TOPO_NO_FACE);
		if (ret != 1)
		    goto error;
		start = invalid;
		invalid = -1;
		dustbin_row = -1;
		continue;
	    }

    topo = (struct gaia_topology *) accessor;
    if (!check_empty_topology (topo))
	goto not_empty;
    if (!check_matching_srid_dims (accessor, geom->Srid, geom->DimensionModel))
	goto invalid_geom;

    start_topo_savepoint (sqlite, cache);
    ret = auxtopo_insert_into_topology (accessor, geom, 0.0, -1, -1);
    if (!ret)
	rollback_topo_savepoint (sqlite, cache);
    else
	release_topo_savepoint (sqlite, cache);
    if (!ret)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
................................................................................
	gaiaFreeGeomColl (linestring);
    msg =
	"SQL/MM Spatial exception - invalid geometry (mismatching SRID or dimensions).";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;
}












































































































































































































































































































































































SPATIALITE_PRIVATE void
fnctaux_TopoGeo_SubdivideLines (const void *xcontext, int argc,
				const void *xargv)
{
/* SQL function:
/ TopoGeo_SubdivideLines ( Geometry geom, int line_max_points,
................................................................................
    start_topo_savepoint (sqlite, cache);
    ret =
	gaiaTopoGeo_FromGeoTable (accessor, db_prefix, xtable, xcolumn,
				  tolerance, line_max_points, max_length);
    if (!ret)
	rollback_topo_savepoint (sqlite, cache);
    else












































































































































































	release_topo_savepoint (sqlite, cache);
    free (xtable);
    free (xcolumn);
    if (!ret)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
	  gaiatopo_set_last_error_msg (accessor, msg);
................................................................................
      }
    release_topo_savepoint (sqlite, cache);

    ret =
	gaiaTopoGeo_FromGeoTableExtended (accessor, sql_in, sql_out, sql_in2,
					  tolerance, line_max_points,
					  max_length);








































































































































































































































































    free (xtable);
    free (xcolumn);
    sqlite3_free (sql_in);
    sqlite3_free (sql_out);
    sqlite3_free (sql_in2);
    sqlite3_result_int (context, ret);
    return;

    topo = (struct gaia_topology *) accessor;
    if (!check_empty_topology (topo))
	goto not_empty;
    if (!check_matching_srid_dims (accessor, geom->Srid, geom->DimensionModel))
	goto invalid_geom;

    start_topo_savepoint (sqlite, cache);
    ret = auxtopo_insert_into_topology (accessor, geom, 0.0, -1, -1, GAIA_MODE_TOPO_FACE);
    if (!ret)
	rollback_topo_savepoint (sqlite, cache);
    else
	release_topo_savepoint (sqlite, cache);
    if (!ret)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
................................................................................
	gaiaFreeGeomColl (linestring);
    msg =
	"SQL/MM Spatial exception - invalid geometry (mismatching SRID or dimensions).";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;
}

SPATIALITE_PRIVATE void
fnctaux_TopoGeo_AddLineStringNoFace (const void *xcontext, int argc,
			       const void *xargv)
{
/* SQL function:
/ TopoGeo_AddLineStringNoFace ( text topology-name, Geometry (multi)linestring, 
/                               double tolerance )
/
/ returns: a comma separated list of all IDs of corresponding Edges on success
/ raises an exception on failure
*/
    const char *msg;
    int ret;
    char xedge_id[64];
    sqlite3_int64 *edge_ids = NULL;
    int ids_count = 0;
    char *retlist = NULL;
    char *savelist;
    int i;
    const char *topo_name;
    unsigned char *p_blob;
    int n_bytes;
    gaiaGeomCollPtr linestring = NULL;
    gaiaLinestringPtr ln;
    double tolerance;
    int invalid = 0;
    GaiaTopologyAccessorPtr accessor = NULL;
    int gpkg_amphibious = 0;
    int gpkg_mode = 0;
    sqlite3_context *context = (sqlite3_context *) xcontext;
    sqlite3_value **argv = (sqlite3_value **) xargv;
    sqlite3 *sqlite = sqlite3_context_db_handle (context);
    struct splite_internal_cache *cache = sqlite3_user_data (context);
    GAIA_UNUSED ();		/* LCOV_EXCL_LINE */
    if (cache != NULL)
      {
	  gpkg_amphibious = cache->gpkg_amphibious_mode;
	  gpkg_mode = cache->gpkg_mode;
      }
    if (sqlite3_value_type (argv[0]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	topo_name = (const char *) sqlite3_value_text (argv[0]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[1]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[1]) == SQLITE_BLOB)
      {
	  p_blob = (unsigned char *) sqlite3_value_blob (argv[1]);
	  n_bytes = sqlite3_value_bytes (argv[1]);
      }
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[2]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
      {
	  int t = sqlite3_value_int (argv[2]);
	  tolerance = t;
      }
    else if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
	tolerance = sqlite3_value_int (argv[2]);
    else
	goto invalid_arg;

/* attempting to get a Linestring Geometry */
    linestring =
	gaiaFromSpatiaLiteBlobWkbEx (p_blob, n_bytes, gpkg_mode,
				     gpkg_amphibious);
    if (!linestring)
	goto invalid_arg;
    if (linestring->FirstPoint != NULL)
	invalid = 1;
    if (linestring->FirstPolygon != NULL)
	invalid = 1;
    if (linestring->FirstLinestring == NULL)
	invalid = 1;
    if (invalid)
	goto invalid_arg;

/* attempting to get a Topology Accessor */
    accessor = gaiaGetTopology (sqlite, cache, topo_name);
    if (accessor == NULL)
	goto no_topo;
    gaiatopo_reset_last_error_msg (accessor);
    if (!check_matching_srid_dims
	(accessor, linestring->Srid, linestring->DimensionModel))
	goto invalid_geom;

    start_topo_savepoint (sqlite, cache);
    ln = linestring->FirstLinestring;
    while (ln != NULL)
      {
	  /* looping on individual Linestrings */
	  ret =
	      gaiaTopoGeo_AddLineStringNoFace (accessor, ln, tolerance, &edge_ids,
					 &ids_count);
	  if (!ret)
	      break;
	  for (i = 0; i < ids_count; i++)
	    {
		sprintf (xedge_id, "%lld", edge_ids[i]);
		if (retlist == NULL)
		    retlist = sqlite3_mprintf ("%s", xedge_id);
		else
		  {
		      savelist = retlist;
		      retlist = sqlite3_mprintf ("%s, %s", savelist, xedge_id);
		      sqlite3_free (savelist);
		  }
	    }
	  free (edge_ids);
	  ln = ln->Next;
      }

    if (!ret)
	rollback_topo_savepoint (sqlite, cache);
    else
	release_topo_savepoint (sqlite, cache);
    gaiaFreeGeomColl (linestring);
    linestring = NULL;
    if (!ret)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
	  gaiatopo_set_last_error_msg (accessor, msg);
	  sqlite3_result_error (context, msg, -1);
	  sqlite3_free (retlist);
	  return;
      }
    sqlite3_result_text (context, retlist, strlen (retlist), sqlite3_free);
    return;

  no_topo:
    if (linestring != NULL)
	gaiaFreeGeomColl (linestring);
    msg = "SQL/MM Spatial exception - invalid topology name.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  null_arg:
    if (linestring != NULL)
	gaiaFreeGeomColl (linestring);
    msg = "SQL/MM Spatial exception - null argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_arg:
    if (linestring != NULL)
	gaiaFreeGeomColl (linestring);
    msg = "SQL/MM Spatial exception - invalid argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_geom:
    if (linestring != NULL)
	gaiaFreeGeomColl (linestring);
    msg =
	"SQL/MM Spatial exception - invalid geometry (mismatching SRID or dimensions).";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;
}

SPATIALITE_PRIVATE void
fnctaux_TopoGeo_Polygonize (const void *xcontext, int argc,
			       const void *xargv)
{
/* SQL function:
/ TopoGeo_Polygonize ( text topology-name )
*/
    const char *msg;
    int ret;
    const char *topo_name;
    GaiaTopologyAccessorPtr accessor = NULL;
    sqlite3_context *context = (sqlite3_context *) xcontext;
    sqlite3_value **argv = (sqlite3_value **) xargv;
    sqlite3 *sqlite = sqlite3_context_db_handle (context);
    struct splite_internal_cache *cache = sqlite3_user_data (context);
    GAIA_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	topo_name = (const char *) sqlite3_value_text (argv[0]);
    else
	goto invalid_arg;
	
/* attempting to get a Topology Accessor */
    accessor = gaiaGetTopology (sqlite, cache, topo_name);
    if (accessor == NULL)
	goto no_topo;
    gaiatopo_reset_last_error_msg (accessor);

    start_topo_savepoint (sqlite, cache);
    ret = gaiaTopoGeo_Polygonize (accessor);

    if (!ret)
	rollback_topo_savepoint (sqlite, cache);
    else
	release_topo_savepoint (sqlite, cache);
    if (!ret)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
	  gaiatopo_set_last_error_msg (accessor, msg);
	  sqlite3_result_error (context, msg, -1);
	  return;
      }
    sqlite3_result_null (context);
    return;

  no_topo:
    msg = "SQL/MM Spatial exception - invalid topology name.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  null_arg:
    msg = "SQL/MM Spatial exception - null argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_arg:
    msg = "SQL/MM Spatial exception - invalid argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;
}

SPATIALITE_PRIVATE void
fnctaux_TopoSnap (const void *xcontext, int argc, const void *xargv)
{
/* SQL function:
/ ST_TopoSnap ( text topology-name, , Geometry geom, double tolerance,
/               int iterate, int remove_vertices )
/
/ returns: the snapped Geometry
/ raises an exception on failure
*/
    const char *msg;
    const char *topo_name;
    unsigned char *p_blob;
    int n_bytes;
    gaiaGeomCollPtr geom = NULL;
    gaiaGeomCollPtr g2;
    double tolerance;
    int iterate;
    int remove_vertices;
    GaiaTopologyAccessorPtr accessor = NULL;
    int gpkg_amphibious = 0;
    int gpkg_mode = 0;
    sqlite3_context *context = (sqlite3_context *) xcontext;
    sqlite3_value **argv = (sqlite3_value **) xargv;
    sqlite3 *sqlite = sqlite3_context_db_handle (context);
    struct splite_internal_cache *cache = sqlite3_user_data (context);
    GAIA_UNUSED ();		/* LCOV_EXCL_LINE */
    if (cache != NULL)
      {
	  gpkg_amphibious = cache->gpkg_amphibious_mode;
	  gpkg_mode = cache->gpkg_mode;
      }
    if (sqlite3_value_type (argv[0]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	topo_name = (const char *) sqlite3_value_text (argv[0]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[1]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[1]) == SQLITE_BLOB)
      {
	  p_blob = (unsigned char *) sqlite3_value_blob (argv[1]);
	  n_bytes = sqlite3_value_bytes (argv[1]);
      }
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[2]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[2]) == SQLITE_INTEGER)
      {
	  int t = sqlite3_value_int (argv[2]);
	  tolerance = t;
      }
    else if (sqlite3_value_type (argv[2]) == SQLITE_FLOAT)
	tolerance = sqlite3_value_int (argv[2]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[3]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[3]) == SQLITE_INTEGER)
	iterate = sqlite3_value_int (argv[3]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[4]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[4]) == SQLITE_INTEGER)
	remove_vertices = sqlite3_value_int (argv[4]);
    else
	goto invalid_arg;

/* attempting to get a Geometry */
    geom =
	gaiaFromSpatiaLiteBlobWkbEx (p_blob, n_bytes, gpkg_mode,
				     gpkg_amphibious);
    if (!geom)
	goto invalid_arg;

/* attempting to get a Topology Accessor */
    accessor = gaiaGetTopology (sqlite, cache, topo_name);
    if (accessor == NULL)
	goto no_topo;

    gaiatopo_reset_last_error_msg (accessor);
    g2 = gaiaTopoSnap (accessor, geom, tolerance, iterate, remove_vertices);
	gaiaFreeGeomColl (geom);
    if (g2 == NULL)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
	  if (msg != NULL)
	    {
		gaiatopo_set_last_error_msg (accessor, msg);
		sqlite3_result_error (context, msg, -1);
		return;
	    }
	  sqlite3_result_null (context);
	  return;
      }
    gaiaToSpatiaLiteBlobWkbEx (g2, &p_blob, &n_bytes, gpkg_mode);
    gaiaFreeGeomColl (g2);
    if (p_blob == NULL)
	sqlite3_result_null (context);
    else
	sqlite3_result_blob (context, p_blob, n_bytes, free);
    return;

  no_topo:
    if (geom != NULL)
	gaiaFreeGeomColl (geom);
    msg = "SQL/MM Spatial exception - invalid topology name.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  null_arg:
    if (geom != NULL)
	gaiaFreeGeomColl (geom);
    msg = "SQL/MM Spatial exception - null argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_arg:
    if (geom != NULL)
	gaiaFreeGeomColl (geom);
    msg = "SQL/MM Spatial exception - invalid argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;
}

SPATIALITE_PRIVATE void
fnctaux_TopoGeo_SubdivideLines (const void *xcontext, int argc,
				const void *xargv)
{
/* SQL function:
/ TopoGeo_SubdivideLines ( Geometry geom, int line_max_points,
................................................................................
    start_topo_savepoint (sqlite, cache);
    ret =
	gaiaTopoGeo_FromGeoTable (accessor, db_prefix, xtable, xcolumn,
				  tolerance, line_max_points, max_length);
    if (!ret)
	rollback_topo_savepoint (sqlite, cache);
    else
	release_topo_savepoint (sqlite, cache);
    free (xtable);
    free (xcolumn);
    if (!ret)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
	  gaiatopo_set_last_error_msg (accessor, msg);
	  sqlite3_result_error (context, msg, -1);
	  return;
      }
    sqlite3_result_int (context, 1);
    return;

  no_topo:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    msg = "SQL/MM Spatial exception - invalid topology name.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  no_input:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    msg = "SQL/MM Spatial exception - invalid input GeoTable.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  null_arg:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    msg = "SQL/MM Spatial exception - null argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_arg:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    msg = "SQL/MM Spatial exception - invalid argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_geom:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    msg =
	"SQL/MM Spatial exception - invalid GeoTable (mismatching SRID or dimensions).";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;
}

SPATIALITE_PRIVATE void
fnctaux_TopoGeo_FromGeoTableNoFace (const void *xcontext, int argc, const void *xargv)
{
/* SQL function:
/ TopoGeo_FromGeoTableNoFace ( text topology-name, text db-prefix, text table,
/                        text column, double tolerance )
/ TopoGeo_FromGeoTableNoFace ( text topology-name, text db-prefix, text table,
/                        text column, double tolerance, int line_max_points,
/                        double max_length )
/
/ returns: 1 on success
/ raises an exception on failure
*/
    const char *msg;
    int ret;
    const char *topo_name;
    const char *db_prefix;
    const char *table;
    const char *column;
    char *xtable = NULL;
    char *xcolumn = NULL;
    int srid;
    int dims;
    double tolerance;
    int line_max_points = -1;
    double max_length = -1.0;
    GaiaTopologyAccessorPtr accessor = NULL;
    sqlite3_context *context = (sqlite3_context *) xcontext;
    sqlite3_value **argv = (sqlite3_value **) xargv;
    sqlite3 *sqlite = sqlite3_context_db_handle (context);
    struct splite_internal_cache *cache = sqlite3_user_data (context);
    GAIA_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	topo_name = (const char *) sqlite3_value_text (argv[0]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[1]) == SQLITE_NULL)
	db_prefix = "main";
    else if (sqlite3_value_type (argv[1]) == SQLITE_TEXT)
	db_prefix = (const char *) sqlite3_value_text (argv[1]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[2]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[2]) == SQLITE_TEXT)
	table = (const char *) sqlite3_value_text (argv[2]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[3]) == SQLITE_NULL)
	column = NULL;
    else if (sqlite3_value_type (argv[3]) == SQLITE_TEXT)
	column = (const char *) sqlite3_value_text (argv[3]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[4]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[4]) == SQLITE_INTEGER)
      {
	  int t = sqlite3_value_int (argv[4]);
	  tolerance = t;
      }
    else if (sqlite3_value_type (argv[4]) == SQLITE_FLOAT)
	tolerance = sqlite3_value_int (argv[4]);
    else
	goto invalid_arg;
    if (argc >= 6)
      {
	  if (sqlite3_value_type (argv[5]) == SQLITE_INTEGER)
	      line_max_points = sqlite3_value_int (argv[5]);
	  else
	      goto invalid_arg;
      }
    if (argc >= 7)
      {
	  if (sqlite3_value_type (argv[6]) == SQLITE_INTEGER)
	    {
		int max = sqlite3_value_int (argv[6]);
		max_length = max;
	    }
	  else if (sqlite3_value_type (argv[6]) == SQLITE_FLOAT)
	      max_length = sqlite3_value_double (argv[6]);
	  else
	      goto invalid_arg;
      }

/* attempting to get a Topology Accessor */
    accessor = gaiaGetTopology (sqlite, cache, topo_name);
    if (accessor == NULL)
	goto no_topo;
    gaiatopo_reset_last_error_msg (accessor);

/* checking the input GeoTable */
    if (!check_input_geo_table
	(sqlite, db_prefix, table, column, &xtable, &xcolumn, &srid, &dims))
	goto no_input;
    if (!check_matching_srid_dims (accessor, srid, dims))
	goto invalid_geom;

    start_topo_savepoint (sqlite, cache);
    ret =
	gaiaTopoGeo_FromGeoTableNoFace (accessor, db_prefix, xtable, xcolumn,
				  tolerance, line_max_points, max_length);
    if (!ret)
	rollback_topo_savepoint (sqlite, cache);
    else
	release_topo_savepoint (sqlite, cache);
    free (xtable);
    free (xcolumn);
    if (!ret)
      {
	  msg = gaiaGetRtTopoErrorMsg (cache);
	  gaiatopo_set_last_error_msg (accessor, msg);
................................................................................
      }
    release_topo_savepoint (sqlite, cache);

    ret =
	gaiaTopoGeo_FromGeoTableExtended (accessor, sql_in, sql_out, sql_in2,
					  tolerance, line_max_points,
					  max_length);
    free (xtable);
    free (xcolumn);
    sqlite3_free (sql_in);
    sqlite3_free (sql_out);
    sqlite3_free (sql_in2);
    sqlite3_result_int (context, ret);
    return;

  no_topo:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    if (sql_in != NULL)
	sqlite3_free (sql_in);
    if (sql_out != NULL)
	sqlite3_free (sql_out);
    if (sql_in2 != NULL)
	sqlite3_free (sql_in2);
    msg = "SQL/MM Spatial exception - invalid topology name.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  no_input:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    if (sql_in != NULL)
	sqlite3_free (sql_in);
    if (sql_out != NULL)
	sqlite3_free (sql_out);
    if (sql_in2 != NULL)
	sqlite3_free (sql_in2);
    msg = "SQL/MM Spatial exception - invalid input GeoTable.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  null_arg:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    if (sql_in != NULL)
	sqlite3_free (sql_in);
    if (sql_out != NULL)
	sqlite3_free (sql_out);
    if (sql_in2 != NULL)
	sqlite3_free (sql_in2);
    msg = "SQL/MM Spatial exception - null argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_arg:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    if (sql_in != NULL)
	sqlite3_free (sql_in);
    if (sql_out != NULL)
	sqlite3_free (sql_out);
    if (sql_in2 != NULL)
	sqlite3_free (sql_in2);
    msg = "SQL/MM Spatial exception - invalid argument.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  invalid_geom:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    if (sql_in != NULL)
	sqlite3_free (sql_in);
    if (sql_out != NULL)
	sqlite3_free (sql_out);
    if (sql_in2 != NULL)
	sqlite3_free (sql_in2);
    msg =
	"SQL/MM Spatial exception - invalid GeoTable (mismatching SRID or dimensions).";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  no_dustbin_table:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    if (sql_in != NULL)
	sqlite3_free (sql_in);
    if (sql_out != NULL)
	sqlite3_free (sql_out);
    msg = "SQL/MM Spatial exception - unable to create the dustbin table.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;

  no_dustbin_view:
    if (xtable != NULL)
	free (xtable);
    if (xcolumn != NULL)
	free (xcolumn);
    if (sql_in != NULL)
	sqlite3_free (sql_in);
    if (sql_out != NULL)
	sqlite3_free (sql_out);
    if (sql_in2 != NULL)
	sqlite3_free (sql_in2);
    msg = "SQL/MM Spatial exception - unable to create the dustbin view.";
    gaiatopo_set_last_error_msg (accessor, msg);
    sqlite3_result_error (context, msg, -1);
    return;
}

SPATIALITE_PRIVATE void
fnctaux_TopoGeo_FromGeoTableNoFaceExt (const void *xcontext, int argc,
				 const void *xargv)
{
/* SQL function:
/ TopoGeo_FromGeoTableNoFaceExt ( text topology-name, text db-prefix, 
/                                 text table, text column, double tolerance, 
/                                 text dustbin-table, text dustbin-view )
/ TopoGeo_FromGeoTableNoFaceExt ( text topology-name, text db-prefix, 
/                                 text table, text column, double tolerance, 
/                                 text dustbin-table, text dustbin-view,
/                                 int line_max_points, double max_length )
/
/ returns: 1 on success
/ raises an exception on failure
*/
    const char *msg;
    int ret;
    const char *topo_name;
    const char *db_prefix;
    const char *table;
    const char *column;
    char *xtable = NULL;
    char *xcolumn = NULL;
    int srid;
    int dims;
    double tolerance;
    const char *dustbin_table;
    const char *dustbin_view;
    int line_max_points = -1;
    double max_length = -1.0;
    char *sql_in = NULL;
    char *sql_out = NULL;
    char *sql_in2 = NULL;
    GaiaTopologyAccessorPtr accessor = NULL;
    sqlite3_context *context = (sqlite3_context *) xcontext;
    sqlite3_value **argv = (sqlite3_value **) xargv;
    sqlite3 *sqlite = sqlite3_context_db_handle (context);
    struct splite_internal_cache *cache = sqlite3_user_data (context);
    GAIA_UNUSED ();		/* LCOV_EXCL_LINE */
    if (sqlite3_value_type (argv[0]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[0]) == SQLITE_TEXT)
	topo_name = (const char *) sqlite3_value_text (argv[0]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[1]) == SQLITE_NULL)
	db_prefix = "main";
    else if (sqlite3_value_type (argv[1]) == SQLITE_TEXT)
	db_prefix = (const char *) sqlite3_value_text (argv[1]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[2]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[2]) == SQLITE_TEXT)
	table = (const char *) sqlite3_value_text (argv[2]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[3]) == SQLITE_NULL)
	column = NULL;
    else if (sqlite3_value_type (argv[3]) == SQLITE_TEXT)
	column = (const char *) sqlite3_value_text (argv[3]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[4]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[4]) == SQLITE_INTEGER)
      {
	  int t = sqlite3_value_int (argv[4]);
	  tolerance = t;
      }
    else if (sqlite3_value_type (argv[4]) == SQLITE_FLOAT)
	tolerance = sqlite3_value_int (argv[4]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[5]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[5]) == SQLITE_TEXT)
	dustbin_table = (const char *) sqlite3_value_text (argv[5]);
    else
	goto invalid_arg;
    if (sqlite3_value_type (argv[6]) == SQLITE_NULL)
	goto null_arg;
    else if (sqlite3_value_type (argv[6]) == SQLITE_TEXT)
	dustbin_view = (const char *) sqlite3_value_text (argv[6]);
    else
	goto invalid_arg;
    if (argc >= 8)
      {
	  if (sqlite3_value_type (argv[7]) == SQLITE_NULL)
	      goto null_arg;
	  else if (sqlite3_value_type (argv[7]) == SQLITE_INTEGER)
	      line_max_points = sqlite3_value_int (argv[8]);
	  else
	      goto invalid_arg;
      }
    if (argc >= 9)
      {
	  if (sqlite3_value_type (argv[8]) == SQLITE_NULL)
	      goto null_arg;
	  else if (sqlite3_value_type (argv[8]) == SQLITE_INTEGER)
	    {
		int max = sqlite3_value_int (argv[8]);
		max_length = max;
	    }
	  else if (sqlite3_value_type (argv[8]) == SQLITE_FLOAT)
	      max_length = sqlite3_value_double (argv[8]);
	  else
	      goto invalid_arg;
      }

/* attempting to get a Topology Accessor */
    accessor = gaiaGetTopology (sqlite, cache, topo_name);
    if (accessor == NULL)
	goto no_topo;
    gaiatopo_reset_last_error_msg (accessor);

/* checking the input GeoTable */
    if (!check_input_geo_table
	(sqlite, db_prefix, table, column, &xtable, &xcolumn, &srid, &dims))
	goto no_input;
    if (!check_matching_srid_dims (accessor, srid, dims))
	goto invalid_geom;

/* attempting to create the dustbin table and view */
    start_topo_savepoint (sqlite, cache);
    if (!create_dustbin_table (sqlite, db_prefix, xtable, dustbin_table))
      {
	  rollback_topo_savepoint (sqlite, cache);
	  goto no_dustbin_table;
      }
    if (!create_dustbin_view
	(sqlite, db_prefix, xtable, xcolumn, dustbin_table, dustbin_view,
	 &sql_in, &sql_out, &sql_in2))
      {
	  rollback_topo_savepoint (sqlite, cache);
	  goto no_dustbin_view;
      }
    release_topo_savepoint (sqlite, cache);

    ret =
	gaiaTopoGeo_FromGeoTableNoFaceExtended (accessor, sql_in, sql_out, sql_in2,
					  tolerance, line_max_points,
					  max_length);
    free (xtable);
    free (xcolumn);
    sqlite3_free (sql_in);
    sqlite3_free (sql_out);
    sqlite3_free (sql_in2);
    sqlite3_result_int (context, ret);
    return;

#define TOPOLOGY_PRIVATE
#endif
#else
#define TOPOLOGY_PRIVATE __attribute__ ((visibility("hidden")))
#endif
#endif




struct gaia_topology
{
/* a struct wrapping a Topology Accessor Object */
    const void *cache;
    sqlite3 *db_handle;
    char *topology_name;
    int srid;
................................................................................
						 gaiaGeomCollPtr geom);

TOPOLOGY_PRIVATE int auxtopo_insert_into_topology (GaiaTopologyAccessorPtr
						   accessor,
						   gaiaGeomCollPtr geom,
						   double tolerance,
						   int line_max_points,
						   double max_length);


/* prototypes for functions creating some SQL prepared statement */
TOPOLOGY_PRIVATE sqlite3_stmt
    * do_create_stmt_getNodeWithinDistance2D (GaiaTopologyAccessorPtr accessor);

TOPOLOGY_PRIVATE sqlite3_stmt

#define TOPOLOGY_PRIVATE
#endif
#else
#define TOPOLOGY_PRIVATE __attribute__ ((visibility("hidden")))
#endif
#endif

#define GAIA_MODE_TOPO_FACE		0x00
#define GAIA_MODE_TOPO_NO_FACE	0xbb

struct gaia_topology
{
/* a struct wrapping a Topology Accessor Object */
    const void *cache;
    sqlite3 *db_handle;
    char *topology_name;
    int srid;
................................................................................
						 gaiaGeomCollPtr geom);

TOPOLOGY_PRIVATE int auxtopo_insert_into_topology (GaiaTopologyAccessorPtr
						   accessor,
						   gaiaGeomCollPtr geom,
						   double tolerance,
						   int line_max_points,
						   double max_length, int mode);


/* prototypes for functions creating some SQL prepared statement */
TOPOLOGY_PRIVATE sqlite3_stmt
    * do_create_stmt_getNodeWithinDistance2D (GaiaTopologyAccessorPtr accessor);

TOPOLOGY_PRIVATE sqlite3_stmt

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_cache_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_cache_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_freexl_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_freexl_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_geosadvanced_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_geosadvanced_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_gpkgcache_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_gpkgcache_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_gpkgnocache_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_gpkgnocache_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_nocache_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_nocache_tests

	pointsnapseed11.testcase \
	pointsnapseed12.testcase \
	pointsnapseed13.testcase \
	pointsnapseed14.testcase \
	pointsnapseed15.testcase \
	pointsnapseed16.testcase \
	pointsnapseed17.testcase \





	remedgemodface1.testcase \
	remedgemodface2.testcase \
	remedgemodface3.testcase \
	remedgemodface4.testcase \
	remedgemodface5.testcase \
	remedgemodface6.testcase \
	remedgemodface7.testcase \
................................................................................
	topogeoaddline11.testcase \
	topogeoaddline12.testcase \
	topogeoaddline13.testcase \
	topogeoaddline14.testcase \
	topogeoaddline15.testcase \
	topogeoaddline16.testcase \
	topogeoaddline17.testcase \

















	topogeoclone1.testcase \
	topogeoclone2.testcase \
	topogeoclone3.testcase \
	topogeoclone4.testcase \
	topogeoclone5.testcase \
	topogeoclone6.testcase \
	topogeoclone7.testcase \
................................................................................
	topogeofromext33.testcase \
	topogeofromext34.testcase \
	topogeofromext35.testcase \
	topogeofromext36.testcase \
	topogeofromext37.testcase \
	topogeofromext38.testcase \
	topogeofromext39.testcase \







































	topogeofromtable1.testcase \
	topogeofromtable2.testcase \
	topogeofromtable3.testcase \
	topogeofromtable4.testcase \
	topogeofromtable5.testcase \
	topogeofromtable6.testcase \
	topogeofromtable7.testcase \
................................................................................
	topogeofromtable24.testcase \
	topogeofromtable25.testcase \
	topogeofromtable26.testcase \
	topogeofromtable27.testcase \
	topogeofromtable28.testcase \
	topogeofromtable29.testcase \
	topogeofromtable30.testcase \






























	topogeosplitline1.testcase \
	topogeosplitline2.testcase \
	topogeosplitline3.testcase \
	topogeosplitline4.testcase \
	topogeosplitline5.testcase \
	topogeosplitline6.testcase \
	topogeosplitline7.testcase \
................................................................................
	toponettotablegen25.testcase \
	toponettotablegen26.testcase \
	toponettotablegen27.testcase \
	toponettotablegen28.testcase \
	toponettotablegen29.testcase \
	toponettotablegen30.testcase \
	toponettotablegen31.testcase \





















	validatetopogeo1.testcase \
	validatetopogeo2.testcase \
	validatetopogeo3.testcase \
	validatetopogeo4.testcase \
	validatetopogeo5.testcase \
	validlogicalnet1.testcase \
	validlogicalnet2.testcase \

	pointsnapseed11.testcase \
	pointsnapseed12.testcase \
	pointsnapseed13.testcase \
	pointsnapseed14.testcase \
	pointsnapseed15.testcase \
	pointsnapseed16.testcase \
	pointsnapseed17.testcase \
	polygonize1.testcase \
	polygonize2.testcase \
	polygonize3.testcase \
	polygonize4.testcase \
	polygonize5.testcase \
	remedgemodface1.testcase \
	remedgemodface2.testcase \
	remedgemodface3.testcase \
	remedgemodface4.testcase \
	remedgemodface5.testcase \
	remedgemodface6.testcase \
	remedgemodface7.testcase \
................................................................................
	topogeoaddline11.testcase \
	topogeoaddline12.testcase \
	topogeoaddline13.testcase \
	topogeoaddline14.testcase \
	topogeoaddline15.testcase \
	topogeoaddline16.testcase \
	topogeoaddline17.testcase \
	topogeoaddlinenf1.testcase \
	topogeoaddlinenf2.testcase \
	topogeoaddlinenf3.testcase \
	topogeoaddlinenf4.testcase \
	topogeoaddlinenf5.testcase \
	topogeoaddlinenf6.testcase \
	topogeoaddlinenf7.testcase \
	topogeoaddlinenf8.testcase \
	topogeoaddlinenf9.testcase \
	topogeoaddlinenf10.testcase \
	topogeoaddlinenf11.testcase \
	topogeoaddlinenf12.testcase \
	topogeoaddlinenf13.testcase \
	topogeoaddlinenf14.testcase \
	topogeoaddlinenf15.testcase \
	topogeoaddlinenf16.testcase \
	topogeoaddlinenf17.testcase \
	topogeoclone1.testcase \
	topogeoclone2.testcase \
	topogeoclone3.testcase \
	topogeoclone4.testcase \
	topogeoclone5.testcase \
	topogeoclone6.testcase \
	topogeoclone7.testcase \
................................................................................
	topogeofromext33.testcase \
	topogeofromext34.testcase \
	topogeofromext35.testcase \
	topogeofromext36.testcase \
	topogeofromext37.testcase \
	topogeofromext38.testcase \
	topogeofromext39.testcase \
	topogeofromextnf1.testcase \
	topogeofromextnf2.testcase \
	topogeofromextnf3.testcase \
	topogeofromextnf4.testcase \
	topogeofromextnf5.testcase \
	topogeofromextnf6.testcase \
	topogeofromextnf7.testcase \
	topogeofromextnf8.testcase \
	topogeofromextnf9.testcase \
	topogeofromextnf10.testcase \
	topogeofromextnf11.testcase \
	topogeofromextnf12.testcase \
	topogeofromextnf13.testcase \
	topogeofromextnf14.testcase \
	topogeofromextnf15.testcase \
	topogeofromextnf16.testcase \
	topogeofromextnf17.testcase \
	topogeofromextnf18.testcase \
	topogeofromextnf19.testcase \
	topogeofromextnf20.testcase \
	topogeofromextnf21.testcase \
	topogeofromextnf22.testcase \
	topogeofromextnf23.testcase \
	topogeofromextnf24.testcase \
	topogeofromextnf25.testcase \
	topogeofromextnf26.testcase \
	topogeofromextnf27.testcase \
	topogeofromextnf28.testcase \
	topogeofromextnf29.testcase \
	topogeofromextnf30.testcase \
	topogeofromextnf31.testcase \
	topogeofromextnf32.testcase \
	topogeofromextnf33.testcase \
	topogeofromextnf34.testcase \
	topogeofromextnf35.testcase \
	topogeofromextnf36.testcase \
	topogeofromextnf37.testcase \
	topogeofromextnf38.testcase \
	topogeofromextnf39.testcase \
	topogeofromtable1.testcase \
	topogeofromtable2.testcase \
	topogeofromtable3.testcase \
	topogeofromtable4.testcase \
	topogeofromtable5.testcase \
	topogeofromtable6.testcase \
	topogeofromtable7.testcase \
................................................................................
	topogeofromtable24.testcase \
	topogeofromtable25.testcase \
	topogeofromtable26.testcase \
	topogeofromtable27.testcase \
	topogeofromtable28.testcase \
	topogeofromtable29.testcase \
	topogeofromtable30.testcase \
	topogeofromtablenf1.testcase \
	topogeofromtablenf2.testcase \
	topogeofromtablenf3.testcase \
	topogeofromtablenf4.testcase \
	topogeofromtablenf5.testcase \
	topogeofromtablenf6.testcase \
	topogeofromtablenf7.testcase \
	topogeofromtablenf8.testcase \
	topogeofromtablenf9.testcase \
	topogeofromtablenf10.testcase \
	topogeofromtablenf11.testcase \
	topogeofromtablenf12.testcase \
	topogeofromtablenf13.testcase \
	topogeofromtablenf14.testcase \
	topogeofromtablenf15.testcase \
	topogeofromtablenf16.testcase \
	topogeofromtablenf17.testcase \
	topogeofromtablenf18.testcase \
	topogeofromtablenf19.testcase \
	topogeofromtablenf20.testcase \
	topogeofromtablenf21.testcase \
	topogeofromtablenf22.testcase \
	topogeofromtablenf23.testcase \
	topogeofromtablenf24.testcase \
	topogeofromtablenf25.testcase \
	topogeofromtablenf26.testcase \
	topogeofromtablenf27.testcase \
	topogeofromtablenf28.testcase \
	topogeofromtablenf29.testcase \
	topogeofromtablenf30.testcase \
	topogeosplitline1.testcase \
	topogeosplitline2.testcase \
	topogeosplitline3.testcase \
	topogeosplitline4.testcase \
	topogeosplitline5.testcase \
	topogeosplitline6.testcase \
	topogeosplitline7.testcase \
................................................................................
	toponettotablegen25.testcase \
	toponettotablegen26.testcase \
	toponettotablegen27.testcase \
	toponettotablegen28.testcase \
	toponettotablegen29.testcase \
	toponettotablegen30.testcase \
	toponettotablegen31.testcase \
	toposnap1.testcase \
	toposnap2.testcase \
	toposnap3.testcase \
	toposnap4.testcase \
	toposnap5.testcase \
	toposnap6.testcase \
	toposnap7.testcase \
	toposnap8.testcase \
	toposnap9.testcase \
	toposnap10.testcase \
	toposnap11.testcase \
	toposnap12.testcase \
	toposnap13.testcase \
	toposnap14.testcase \
	toposnap15.testcase \
	toposnap16.testcase \
	toposnap17.testcase \
	toposnap18.testcase \
	toposnap19.testcase \
	toposnap20.testcase \
	toposnap21.testcase \
	validatetopogeo1.testcase \
	validatetopogeo2.testcase \
	validatetopogeo3.testcase \
	validatetopogeo4.testcase \
	validatetopogeo5.testcase \
	validlogicalnet1.testcase \
	validlogicalnet2.testcase \

	pointsnapseed11.testcase \
	pointsnapseed12.testcase \
	pointsnapseed13.testcase \
	pointsnapseed14.testcase \
	pointsnapseed15.testcase \
	pointsnapseed16.testcase \
	pointsnapseed17.testcase \





	remedgemodface1.testcase \
	remedgemodface2.testcase \
	remedgemodface3.testcase \
	remedgemodface4.testcase \
	remedgemodface5.testcase \
	remedgemodface6.testcase \
	remedgemodface7.testcase \
................................................................................
	topogeoaddline11.testcase \
	topogeoaddline12.testcase \
	topogeoaddline13.testcase \
	topogeoaddline14.testcase \
	topogeoaddline15.testcase \
	topogeoaddline16.testcase \
	topogeoaddline17.testcase \

















	topogeoclone1.testcase \
	topogeoclone2.testcase \
	topogeoclone3.testcase \
	topogeoclone4.testcase \
	topogeoclone5.testcase \
	topogeoclone6.testcase \
	topogeoclone7.testcase \
................................................................................
	topogeofromext33.testcase \
	topogeofromext34.testcase \
	topogeofromext35.testcase \
	topogeofromext36.testcase \
	topogeofromext37.testcase \
	topogeofromext38.testcase \
	topogeofromext39.testcase \







































	topogeofromtable1.testcase \
	topogeofromtable2.testcase \
	topogeofromtable3.testcase \
	topogeofromtable4.testcase \
	topogeofromtable5.testcase \
	topogeofromtable6.testcase \
	topogeofromtable7.testcase \
................................................................................
	topogeofromtable24.testcase \
	topogeofromtable25.testcase \
	topogeofromtable26.testcase \
	topogeofromtable27.testcase \
	topogeofromtable28.testcase \
	topogeofromtable29.testcase \
	topogeofromtable30.testcase \






























	topogeosplitline1.testcase \
	topogeosplitline2.testcase \
	topogeosplitline3.testcase \
	topogeosplitline4.testcase \
	topogeosplitline5.testcase \
	topogeosplitline6.testcase \
	topogeosplitline7.testcase \
................................................................................
	toponettotablegen25.testcase \
	toponettotablegen26.testcase \
	toponettotablegen27.testcase \
	toponettotablegen28.testcase \
	toponettotablegen29.testcase \
	toponettotablegen30.testcase \
	toponettotablegen31.testcase \





















	validatetopogeo1.testcase \
	validatetopogeo2.testcase \
	validatetopogeo3.testcase \
	validatetopogeo4.testcase \
	validatetopogeo5.testcase \
	validlogicalnet1.testcase \
	validlogicalnet2.testcase \

	pointsnapseed11.testcase \
	pointsnapseed12.testcase \
	pointsnapseed13.testcase \
	pointsnapseed14.testcase \
	pointsnapseed15.testcase \
	pointsnapseed16.testcase \
	pointsnapseed17.testcase \
	polygonize1.testcase \
	polygonize2.testcase \
	polygonize3.testcase \
	polygonize4.testcase \
	polygonize5.testcase \
	remedgemodface1.testcase \
	remedgemodface2.testcase \
	remedgemodface3.testcase \
	remedgemodface4.testcase \
	remedgemodface5.testcase \
	remedgemodface6.testcase \
	remedgemodface7.testcase \
................................................................................
	topogeoaddline11.testcase \
	topogeoaddline12.testcase \
	topogeoaddline13.testcase \
	topogeoaddline14.testcase \
	topogeoaddline15.testcase \
	topogeoaddline16.testcase \
	topogeoaddline17.testcase \
	topogeoaddlinenf1.testcase \
	topogeoaddlinenf2.testcase \
	topogeoaddlinenf3.testcase \
	topogeoaddlinenf4.testcase \
	topogeoaddlinenf5.testcase \
	topogeoaddlinenf6.testcase \
	topogeoaddlinenf7.testcase \
	topogeoaddlinenf8.testcase \
	topogeoaddlinenf9.testcase \
	topogeoaddlinenf10.testcase \
	topogeoaddlinenf11.testcase \
	topogeoaddlinenf12.testcase \
	topogeoaddlinenf13.testcase \
	topogeoaddlinenf14.testcase \
	topogeoaddlinenf15.testcase \
	topogeoaddlinenf16.testcase \
	topogeoaddlinenf17.testcase \
	topogeoclone1.testcase \
	topogeoclone2.testcase \
	topogeoclone3.testcase \
	topogeoclone4.testcase \
	topogeoclone5.testcase \
	topogeoclone6.testcase \
	topogeoclone7.testcase \
................................................................................
	topogeofromext33.testcase \
	topogeofromext34.testcase \
	topogeofromext35.testcase \
	topogeofromext36.testcase \
	topogeofromext37.testcase \
	topogeofromext38.testcase \
	topogeofromext39.testcase \
	topogeofromextnf1.testcase \
	topogeofromextnf2.testcase \
	topogeofromextnf3.testcase \
	topogeofromextnf4.testcase \
	topogeofromextnf5.testcase \
	topogeofromextnf6.testcase \
	topogeofromextnf7.testcase \
	topogeofromextnf8.testcase \
	topogeofromextnf9.testcase \
	topogeofromextnf10.testcase \
	topogeofromextnf11.testcase \
	topogeofromextnf12.testcase \
	topogeofromextnf13.testcase \
	topogeofromextnf14.testcase \
	topogeofromextnf15.testcase \
	topogeofromextnf16.testcase \
	topogeofromextnf17.testcase \
	topogeofromextnf18.testcase \
	topogeofromextnf19.testcase \
	topogeofromextnf20.testcase \
	topogeofromextnf21.testcase \
	topogeofromextnf22.testcase \
	topogeofromextnf23.testcase \
	topogeofromextnf24.testcase \
	topogeofromextnf25.testcase \
	topogeofromextnf26.testcase \
	topogeofromextnf27.testcase \
	topogeofromextnf28.testcase \
	topogeofromextnf29.testcase \
	topogeofromextnf30.testcase \
	topogeofromextnf31.testcase \
	topogeofromextnf32.testcase \
	topogeofromextnf33.testcase \
	topogeofromextnf34.testcase \
	topogeofromextnf35.testcase \
	topogeofromextnf36.testcase \
	topogeofromextnf37.testcase \
	topogeofromextnf38.testcase \
	topogeofromextnf39.testcase \
	topogeofromtable1.testcase \
	topogeofromtable2.testcase \
	topogeofromtable3.testcase \
	topogeofromtable4.testcase \
	topogeofromtable5.testcase \
	topogeofromtable6.testcase \
	topogeofromtable7.testcase \
................................................................................
	topogeofromtable24.testcase \
	topogeofromtable25.testcase \
	topogeofromtable26.testcase \
	topogeofromtable27.testcase \
	topogeofromtable28.testcase \
	topogeofromtable29.testcase \
	topogeofromtable30.testcase \
	topogeofromtablenf1.testcase \
	topogeofromtablenf2.testcase \
	topogeofromtablenf3.testcase \
	topogeofromtablenf4.testcase \
	topogeofromtablenf5.testcase \
	topogeofromtablenf6.testcase \
	topogeofromtablenf7.testcase \
	topogeofromtablenf8.testcase \
	topogeofromtablenf9.testcase \
	topogeofromtablenf10.testcase \
	topogeofromtablenf11.testcase \
	topogeofromtablenf12.testcase \
	topogeofromtablenf13.testcase \
	topogeofromtablenf14.testcase \
	topogeofromtablenf15.testcase \
	topogeofromtablenf16.testcase \
	topogeofromtablenf17.testcase \
	topogeofromtablenf18.testcase \
	topogeofromtablenf19.testcase \
	topogeofromtablenf20.testcase \
	topogeofromtablenf21.testcase \
	topogeofromtablenf22.testcase \
	topogeofromtablenf23.testcase \
	topogeofromtablenf24.testcase \
	topogeofromtablenf25.testcase \
	topogeofromtablenf26.testcase \
	topogeofromtablenf27.testcase \
	topogeofromtablenf28.testcase \
	topogeofromtablenf29.testcase \
	topogeofromtablenf30.testcase \
	topogeosplitline1.testcase \
	topogeosplitline2.testcase \
	topogeosplitline3.testcase \
	topogeosplitline4.testcase \
	topogeosplitline5.testcase \
	topogeosplitline6.testcase \
	topogeosplitline7.testcase \
................................................................................
	toponettotablegen25.testcase \
	toponettotablegen26.testcase \
	toponettotablegen27.testcase \
	toponettotablegen28.testcase \
	toponettotablegen29.testcase \
	toponettotablegen30.testcase \
	toponettotablegen31.testcase \
	toposnap1.testcase \
	toposnap2.testcase \
	toposnap3.testcase \
	toposnap4.testcase \
	toposnap5.testcase \
	toposnap6.testcase \
	toposnap7.testcase \
	toposnap8.testcase \
	toposnap9.testcase \
	toposnap10.testcase \
	toposnap11.testcase \
	toposnap12.testcase \
	toposnap13.testcase \
	toposnap14.testcase \
	toposnap15.testcase \
	toposnap16.testcase \
	toposnap17.testcase \
	toposnap18.testcase \
	toposnap19.testcase \
	toposnap20.testcase \
	toposnap21.testcase \
	validatetopogeo1.testcase \
	validatetopogeo2.testcase \
	validatetopogeo3.testcase \
	validatetopogeo4.testcase \
	validatetopogeo5.testcase \
	validlogicalnet1.testcase \
	validlogicalnet2.testcase \

TopoGeo_Polygonize - NULL Topology
:memory: #use in-memory database
SELECT TopoGeo_Polygonize(NULL);
1 # rows (not including the header row)
1 # columns
TopoGeo_Polygonize(NULL)
SQL/MM Spatial exception - null argument.

TopoGeo_Polygonize - Int Topology
:memory: #use in-memory database
SELECT TopoGeo_Polygonize(1);
1 # rows (not including the header row)
1 # columns
TopoGeo_Polygonize(1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_Polygonize - Double Topology
:memory: #use in-memory database
SELECT TopoGeo_Polygonize(1.1);
1 # rows (not including the header row)
1 # columns
TopoGeo_Polygonize(1.1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_Polygonize - BLOB Topology
:memory: #use in-memory database
SELECT TopoGeo_Polygonize(zeroblob(4));
1 # rows (not including the header row)
1 # columns
TopoGeo_Polygonize(zeroblob(4))
SQL/MM Spatial exception - invalid argument.

TopoGeo_Polygonize - Text Topology
:memory: #use in-memory database
SELECT TopoGeo_Polygonize('topoW');
1 # rows (not including the header row)
1 # columns
TopoGeo_Polygonize('topoW')
SQL/MM Spatial exception - invalid topology name.

TopoGeo_AddLineStringNoFace - NULL Topology
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace(NULL, GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace(NULL, GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0)
SQL/MM Spatial exception - null argument.

TopoGeo_AddLineStringNoFace - Double Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', 1.1, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', 1.1, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - NULL Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', NULL, 0)
SQL/MM Spatial exception - null argument.

TopoGeo_AddLineStringNoFace - Text Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', 'geom', 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', 'geom', 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', zeroblob(4), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', zeroblob(4), 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Point Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', MakePoint(0, 1, 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', MakePoint(0, 1, 4326), 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Polygon Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', GeomFromText('POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))', 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', GeomFromText('POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))', 4326), 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - MULTILINESTRING Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', GeomFromText('MULTILINESTRING((0 0, 1 1), (2 2, 3 3))', 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', GeomFromText('MULTILINESTRING((0 0, 1 1), (2 2, 3 3))', 4326), 0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_AddLineStringNoFace - NULL Tolerance
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', MakePoint(1, 2, 4326), NULL);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', MakePoint(1, 2, 4326), NULL)
SQL/MM Spatial exception - null argument.

TopoGeo_AddLineStringNoFace - Int Topology
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace(1, GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace(1, GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Double Topology
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace(1.5, GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace(1.5, GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Blob Topology
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace(zeroblob(4), GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace(zeroblob(4), GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Text Topology
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_AddLineStringNoFace - Double Tolerance
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0.0);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), 0.0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_AddLineStringNoFace - BLOB Tolerance
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), zeroblob(4));
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), zeroblob(4))
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Text Tolerance
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), 'tol');
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', GeomFromText('LINESTRING(0 0, 1 1)', 4326), 'tol')
SQL/MM Spatial exception - invalid argument.

TopoGeo_AddLineStringNoFace - Int Geometry
:memory: #use in-memory database
SELECT TopoGeo_AddLineStringNoFace('topology', -1, 1);
1 # rows (not including the header row)
1 # columns
TopoGeo_AddLineStringNoFace('topology', -1, 1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - NULL Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt(NULL, NULL, 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt(NULL, NULL, 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFaceExt - NULL table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, NULL, NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, NULL, NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFaceExt - INT table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 1, NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 1, NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Double table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 1.2, NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 1.2, NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, zeroblob(4), NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, zeroblob(4), NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Text Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', 'column', 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', 'column', 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFaceExt - Int Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', 1, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', 1, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Double Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', 1.2, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', 1.2, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', zeroblob(4), 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', zeroblob(4), 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - NULL tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, NULL, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, NULL, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFaceExt - Text tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 'zero', 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 'zero', 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Int Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt(1, NULL, 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt(1, NULL, 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, zeroblob(4), 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, zeroblob(4), 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Double tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFaceExt - NULL line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', NULL, -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', NULL, -1)
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFaceExt - Double line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', 1.5, -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', 1.5, -1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Text line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', 'abc', -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', 'abc', -1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', zeroblob(4), -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', zeroblob(4), -1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Integer line-max-points / Integer max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, -1)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFaceExt - NULL max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, NULL);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, NULL)
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, zeroblob(4));
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, zeroblob(4))
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Text max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, 'abc');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, 'abc')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Double Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt(1.5, NULL, 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt(1.5, NULL, 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Double max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, 5000.0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview', -1, 5000.0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFaceExt - NULL dustbin-table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, NULL, 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, NULL, 'dustbinview')
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFaceExt - INT dustbin-table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1, 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1, 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - DOUBLE dustbin-table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1.2, 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1.2, 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - DOUBLE dustbin-table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1.2, 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1.2, 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB dustbin-table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, zeroblob(5), 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, zeroblob(5), 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - NULL dustbin-view
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 'dustbin', NULL);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, NULL, 'dustbin')
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFaceExt - INT dustbin-view
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 'dustbin', 1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1, 'dustbin')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - DOUBLE dustbin-view
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 'dustbin', 1.2);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 1.2, 'dustbin')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB dustbin-view
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 'dustbin', zeroblob(4));
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0.001, 'dustbin', zeroblob(4))
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Blob Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt(zeroblob(4), NULL, 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt(zeroblob(4), NULL, 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Text Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', NULL, 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFaceExt - TEXT prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', 'a', 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', 'a', 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFaceExt - INT prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', 1, 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', 1, 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - Double prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', 1.2, 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', 1.2, 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFaceExt - BLOB prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFaceExt('topology', zeroblob(4), 'table', NULL, 0, 'dustbin', 'dustbinview');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFaceExt('topology', zeroblob(4), 'table', NULL, 0, 'dustbin', 'dustbinview')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - NULL Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace(NULL, NULL, 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace(NULL, NULL, 'table', NULL, 0)
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFace - NULL table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, NULL, NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, NULL, NULL, 0)
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFace - INT table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 1, NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 1, NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Double table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 1.2, NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 1.2, NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - BLOB table
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, zeroblob(4), NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, zeroblob(4), NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Text Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', 'column', 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', 'column', 0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFace - Int Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', 1, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', 1, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Double Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', 1.2, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', 1.2, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - BLOB Column
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', zeroblob(4), 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', zeroblob(4), 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - NULL tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, NULL);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, NULL)
SQL/MM Spatial exception - null argument.

TopoGeo_FromGeoTableNoFace - Text tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 'zero');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 'zero')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Int Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace(1, NULL, 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace(1, NULL, 'table', NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - BLOB tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, zeroblob(4));
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, zeroblob(4))
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Double tolerance
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0.001);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0.001)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFace - NULL line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, NULL, -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, NULL, -1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Double line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, 1.5, -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, 1.5, -1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Text line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, 'abc', -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, 'abc', -1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - BLOB line-max-points
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, zeroblob(4), -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, zeroblob(4), -1)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Integer line-max-points / Integer max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, -1);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, -1)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFace - NULL max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, NULL);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, NULL)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - BLOB max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, zeroblob(4));
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, zeroblob(4))
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Text max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, 'abc');
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, 'abc')
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Double Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace(1.5, NULL, 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace(1.5, NULL, 'table', NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Double max-length
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, 5000.0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0, -1, 5000.0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFace - Blob Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace(zeroblob(4), NULL, 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace(zeroblob(4), NULL, 'table', NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Text Topology
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', NULL, 'table', NULL, 0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFace - TEXT prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', 'a', 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', 'a', 'table', NULL, 0)
SQL/MM Spatial exception - invalid topology name.

TopoGeo_FromGeoTableNoFace - INT prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', 1, 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', 1, 'table', NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - Double prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', 1.2, 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', 1.2, 'table', NULL, 0)
SQL/MM Spatial exception - invalid argument.

TopoGeo_FromGeoTableNoFace - BLOB prefix
:memory: #use in-memory database
SELECT TopoGeo_FromGeoTableNoFace('topology', zeroblob(4), 'table', NULL, 0);
1 # rows (not including the header row)
1 # columns
TopoGeo_FromGeoTableNoFace('topology', zeroblob(4), 'table', NULL, 0)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - NULL Topology
:memory: #use in-memory database
SELECT ST_TopoSnap(NULL, MakePoint(1, 2, 4326), -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap(NULL, MakePoint(1, 2, 4326), -1, 1, 1)
SQL/MM Spatial exception - null argument.

ST_TopoSnap - NULL tolerance
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), NULL, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), NULL, 1, 1)
SQL/MM Spatial exception - null argument.

ST_TopoSnap - Text tolerance
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), 'tolerance', 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), 'tolerance', 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - BLOB tolerance
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), zeroblob(12), 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), zeroblob(12), 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - NULL iterate
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, NULL, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, NULL, 1)
SQL/MM Spatial exception - null argument.

ST_TopoSnap - Text iterate
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 'iterate', 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 'iterate', 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - DOUBLE iterate
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1.5, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1.5, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - BLOB iterate
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, zeroblob(4), 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, zeroblob(4), 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - NULL remove_vertices
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, NULL);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, NULL)
SQL/MM Spatial exception - null argument.

ST_TopoSnap - DOUBLE remove_vertices
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, 1.5);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, 1.5)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - BLOB remove_vertices
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, zeroblob(4));
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, zeroblob(4))
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - Int Topology
:memory: #use in-memory database
SELECT ST_TopoSnap(1, MakePoint(1, 2, 4326), -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap(1, MakePoint(1, 2, 4326), -1, 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - non-existing topology
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, 1)
SQL/MM Spatial exception - invalid topology name.

ST_TopoSnap - TEXT remove_vertices
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, 'remove');
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', MakePoint(1, 2, 4326), -1.0, 1, 'remove')
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - Double Topology
:memory: #use in-memory database
SELECT ST_TopoSnap(1.5, MakePoint(1, 2, 4326), -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap(1.5, MakePoint(1, 2, 4326), -1, 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - BLOB Topology
:memory: #use in-memory database
SELECT ST_TopoSnap(zeroblob(10), MakePoint(1, 2, 4326), -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap(zeroblob(10), MakePoint(1, 2, 4326), -1, 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - NULL Geometry
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', NULL, -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', NULL, -1, 1, 1)
SQL/MM Spatial exception - null argument.

ST_TopoSnap - Int Geometry
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', 1, -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', 1, -1, 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - Int Geometry
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', 1-5, -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', 1.5, -1, 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - Text Geometry
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', 'geom', -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', 'geom', -1, 1, 1)
SQL/MM Spatial exception - invalid argument.

ST_TopoSnap - Invalid BLOB Geometry
:memory: #use in-memory database
SELECT ST_TopoSnap('topo', zeroblob(100), -1, 1, 1);
1 # rows (not including the header row)
1 # columns
ST_TopoSnap('topo', zeroblob(100), -1, 1, 1)
SQL/MM Spatial exception - invalid argument.

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_sequence_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_sequence_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_voronoj1_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_voronoj1_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = /usr/local/lib/pkgconfig
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_voronoj2_tests

PACKAGE_STRING = libspatialite 4.4.0-RC1
PACKAGE_TARNAME = libspatialite
PACKAGE_URL = 
PACKAGE_VERSION = 4.4.0-RC1
PATH_SEPARATOR = :
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR = 
PKG_CONFIG_PATH = 
RANLIB = ranlib
SED = /usr/bin/sed
SET_MAKE = 
SHELL = /bin/sh
STRIP = strip
VERSION = 4.4.0-RC1
abs_builddir = /home/sandro/fossil/libspatialite/test/sql_stmt_voronoj2_tests