* Using ctypes interface to libgis and libraster to read raster information to speed up map registration

* Creation and removal of timestamps in the grass file based database is now realized using ctypes and libgis to avoid the execution of timestamp modules
* Database interface connection handling changed 


git-svn-id: https://svn.osgeo.org/grass/grass/trunk@51306 15284696-431f-4ddb-bdfa-cd5b030d7da7

lib/python/temporal/abstract_dataset.py

@@ -199,7 +199,10 @@ class abstract_dataset(object):
             dbif.close()
 
     def is_in_db(self, dbif=None):
-        """!Check if the temporal dataset entry is in the database"""
+        """!Check if the temporal dataset entry is in the database
+        
+           @param dbif: The database interface to be used
+        """
         return self.base.is_in_db(dbif)
 
     def delete(self):
@@ -215,6 +218,8 @@ class abstract_dataset(object):
                            If False the prepared SQL statements are returned and must be executed by the caller.
         """
 
+        dbif, connect = init_dbif(dbif)
+        
         # Build the INSERT SQL statement
         statement = self.base.get_insert_statement_mogrified(dbif)
         if self.is_time_absolute():
@@ -225,9 +230,13 @@ class abstract_dataset(object):
         statement += self.metadata.get_insert_statement_mogrified(dbif)
 
         if execute == True:
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
+	    if connect:
+		dbif.close()
             return ""
 
+        if connect:
+            dbif.close()
         return statement
 
     def update(self, dbif=None, execute=True):
@@ -239,6 +248,8 @@ class abstract_dataset(object):
                            If False the prepared SQL statements are returned and must be executed by the caller.
 	"""
 
+        dbif, connect = init_dbif(dbif)
+        
         # Build the UPDATE SQL statement
         statement = self.base.get_update_statement_mogrified(dbif)
 	if self.is_time_absolute():
@@ -249,9 +260,13 @@ class abstract_dataset(object):
         statement += self.metadata.get_update_statement_mogrified(dbif)
 
         if execute == True:
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
+	    if connect:
+		dbif.close()
             return ""
- 
+
+        if connect:
+            dbif.close()
         return statement
  
     def update_all(self, dbif=None, execute=True):
@@ -263,6 +278,8 @@ class abstract_dataset(object):
                            If False the prepared SQL statements are returned and must be executed by the caller.
 	"""
 
+        dbif, connect = init_dbif(dbif)
+        
         # Build the UPDATE SQL statement
         statement = self.base.get_update_all_statement_mogrified(dbif)
 	if self.is_time_absolute():
@@ -273,9 +290,13 @@ class abstract_dataset(object):
         statement += self.metadata.get_update_all_statement_mogrified(dbif)
 
         if execute == True:
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
+	    if connect:
+		dbif.close()
             return ""
 
+        if connect:
+            dbif.close()
         return statement
 
     def set_time_to_absolute(self):

lib/python/temporal/abstract_map_dataset.py

@@ -49,14 +49,6 @@ class abstract_map_dataset(abstract_dataset):
            @param ident: The name of the register table
         """
         raise IOError("This method must be implemented in the subclasses")
-      
-    def get_timestamp_module_name(self):
-        """!Return the name of the C-module to set the time stamp in the file system"""
-        raise IOError("This method must be implemented in the subclasses")
-   
-    def load(self):
-        """!Load the content of this object from map files"""
-        raise IOError("This method must be implemented in the subclasses")
  
     def check_resolution_with_current_region(self):
         """!Check if the raster or voxel resolution is finer than the current resolution
@@ -66,7 +58,64 @@ class abstract_map_dataset(abstract_dataset):
            Vector maps are alwyas finer than the current region
         """
         raise IOError("This method must be implemented in the subclasses")
+	
+    def has_grass_timestamp(self):
+        """!Check if a grass file bsased time stamp exists for this map. 
+        """
+        raise IOError("This method must be implemented in the subclasses")
+    
+    def write_timestamp_to_grass(self):
+        """!Write the timestamp of this map into the map metadata in the grass file system based spatial
+           database. 
+        """
+        raise IOError("This method must be implemented in the subclasses")
+    
+    def remove_timestamp_from_grass(self):
+        """!Remove the timestamp from the grass file system based spatial database
+        """
+        raise IOError("This method must be implemented in the subclasses")
+	
+    def map_exists(self):
+        """!Return True in case the map exists in the grass spatial database
+        
+           @return True if map exists, False otherwise
+        """        
+        raise IOError("This method must be implemented in the subclasses")
+	        
+    def read_info(self):
+        """!Read the map info from the grass file system based database and store the content 
+           into a dictionary
+        """
+        raise IOError("This method must be implemented in the subclasses")
 
+    def load(self):
+        """!Load the content of this object from the grass file system based database"""
+        raise IOError("This method must be implemented in the subclasses")
+	
+    def _convert_timestamp(self):
+	"""!Convert the valid time into a grass datetime library compatible timestamp string
+	    
+	    This methods works for reltaive and absolute time
+	    
+	    @return the grass timestamp string
+	"""
+	start = ""
+        
+        if self.is_time_absolute():
+	    start_time, end_time, tz = self.get_absolute_time()
+	    start = datetime_to_grass_datetime_string(start_time)
+	    if end_time:
+		end = datetime_to_grass_datetime_string(end_time)
+		start += " / %s"%(end)
+	else:
+	    start_time, end_time, unit = self.get_relative_time()
+	    start = "%i %s"%(int(start_time), unit)
+	    if end_time != None:
+		end = "%i %s"%(int(end_time), unit)
+		start += " / %s"%(end)
+
+	return start
+		        
     def get_map_id(self):
 	"""!Return the map id. The map id is the unique map identifier in grass and must not be equal to the 
 	   primary key identifier (id) of the map in the database. Since vector maps may have layer information,
@@ -134,13 +183,14 @@ class abstract_map_dataset(abstract_dataset):
         string = ""
         if datasets:
             for ds in datasets:
+                if count > 0 and count % 3 == 0:
+                    string += "\n | ............................ "
+                    count = 0
                 if count == 0:
                     string += ds["id"]
                 else:
                     string += ",%s" % ds["id"]
                 count += 1
-                if count > 2:
-                    string += " | ............................ "
         print " | Registered datasets ........ " + string
         print " +----------------------------------------------------------------------------+"
 
@@ -164,6 +214,44 @@ class abstract_map_dataset(abstract_dataset):
             count += 1
         print "registered_datasets=" + string
 
+    def insert(self, dbif=None, execute=True):
+        """!Insert temporal dataset entry into database from the internal structure
+
+	   This functions assures that the timetsamp is written to the grass file system based database
+	    
+           @param dbif: The database interface to be used
+           @param execute: If True the SQL statements will be executed.
+                           If False the prepared SQL statements are returned and must be executed by the caller.
+        """
+        self.write_timestamp_to_grass()
+        return abstract_dataset.insert(self, dbif, execute)
+
+    def update(self, dbif=None, execute=True):
+	"""!Update temporal dataset entry of database from the internal structure
+	   excluding None variables
+	   
+	   This functions assures that the timetsamp is written to the grass file system based database
+
+           @param dbif: The database interface to be used
+           @param execute: If True the SQL statements will be executed.
+                           If False the prepared SQL statements are returned and must be executed by the caller.
+	"""
+        self.write_timestamp_to_grass()
+        return abstract_dataset.update(self, dbif, execute)
+
+    def update_all(self, dbif=None, execute=True):
+	"""!Update temporal dataset entry of database from the internal structure
+	   and include None varuables.
+	   
+	   This functions assures that the timetsamp is written to the grass file system based database
+
+           @param dbif: The database interface to be used
+           @param execute: If True the SQL statements will be executed.
+                           If False the prepared SQL statements are returned and must be executed by the caller.
+	"""
+        self.write_timestamp_to_grass()
+        return abstract_dataset.update_all(self, dbif, execute)
+        
     def set_absolute_time(self, start_time, end_time=None, timezone=None):
         """!Set the absolute time interval with start time and end time
         
@@ -204,8 +292,7 @@ class abstract_map_dataset(abstract_dataset):
     def update_absolute_time(self, start_time, end_time=None, timezone=None, dbif = None):
         """!Update the absolute time
 
-           This method should always be used to set the absolute time. Do not use insert() or update()
-           to the the time. This update functions assures that the *.timestamp commands are invoked.
+	   This functions assures that the timetsamp is written to the grass file system based database
 
            @param start_time: a datetime object specifying the start time of the map
            @param end_time: a datetime object specifying the end time of the map
@@ -220,19 +307,8 @@ class abstract_map_dataset(abstract_dataset):
         if connect == True:
             dbif.close()
 
-        self.write_absolute_time_to_file()
-
-    def write_absolute_time_to_file(self):
-        """!Start the grass timestamp module to set the time in the file system"""
-
-        start_time, end_time, unit = self.get_absolute_time()
-        start = datetime_to_grass_datetime_string(start_time)
-        if end_time:
-            end = datetime_to_grass_datetime_string(end_time)
-            start += " / %s"%(end)
-
-        core.run_command(self.get_timestamp_module_name(), map=self.get_map_id(), date=start)
-
+        self.write_timestamp_to_grass()
+        
     def set_relative_time(self, start_time, end_time, unit):
         """!Set the relative time interval 
         
@@ -278,9 +354,8 @@ class abstract_map_dataset(abstract_dataset):
     def update_relative_time(self, start_time, end_time, unit, dbif = None):
         """!Update the relative time interval
 
-           This method should always be used to set the absolute time. Do not use insert() or update()
-           to the the time. This update functions assures that the *.timestamp commands are invoked.
-
+	   This functions assures that the timetsamp is written to the grass file system based database
+	    
            @param start_time: A double value 
            @param end_time: A double value 
            @param dbif: The database interface to be used
@@ -290,22 +365,11 @@ class abstract_map_dataset(abstract_dataset):
         if self.set_relative_time(start_time, end_time, unit):
             self.relative_time.update_all(dbif)
             self.base.update(dbif)
-            dbif.connection.commit()
 
         if connect == True:
             dbif.close()
 
-        self.write_relative_time_to_file()
-
-    def write_relative_time_to_file(self):
-        """!Start the grass timestamp module to set the time in the file system"""
-
-        start_time, end_time, unit = self.get_relative_time()
-        start = "%i %s"%(int(start_time), unit)
-        if end_time != None:
-            end = "%i %s"%(int(end_time), unit)
-            start += " / %s"%(end)
-        core.run_command(self.get_timestamp_module_name(), map=self.get_map_id(), date=start)
+        self.write_timestamp_to_grass()
 
     def set_spatial_extent(self, north, south, east, west, top=0, bottom=0):
         """!Set the spatial extent of the map
@@ -377,17 +441,11 @@ class abstract_map_dataset(abstract_dataset):
             statement += self.base.get_delete_statement()
 
         if execute == True:
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
 
         # Remove the timestamp from the file system
-        if self.get_type() == "vect":
-	    if self.get_layer():
-		core.run_command(self.get_timestamp_module_name(), map=self.get_map_id(), layer=self.get_layer(), date="none")
-	    else:
-		core.run_command(self.get_timestamp_module_name(), map=self.get_map_id(), date="none")
-	else:
-	    core.run_command(self.get_timestamp_module_name(), map=self.get_map_id(), date="none")
-
+        self.remove_timestamp_from_grass()
+        
         self.reset(None)
 
         if connect == True:
@@ -442,7 +500,7 @@ class abstract_map_dataset(abstract_dataset):
             core.percent(1, 1, 1)
             
         if execute == True:
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
 
         if connect == True:
             dbif.close()

lib/python/temporal/abstract_space_time_dataset.py

@@ -777,7 +777,7 @@ class abstract_space_time_dataset(abstract_dataset):
         statement += self.base.get_delete_statement()
 
         if execute == True:
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
 
         self.reset(None)
 
@@ -945,7 +945,7 @@ class abstract_space_time_dataset(abstract_dataset):
 
         # We need to execute the statement at this time
         if statement != "":
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
 
         statement = ""
 
@@ -968,7 +968,7 @@ class abstract_space_time_dataset(abstract_dataset):
 	    else:
 		sql = "INSERT INTO " + map_register_table + " (id) " + "VALUES (%s);\n"
 
-            statement += dbif._mogrify_sql_statement((sql, (self.base.get_id(),)), dbif)
+            statement += dbif.mogrify_sql_statement((sql, (self.base.get_id(),)))
 
         # Now put the raster name in the stds map register table
 	if dbmi.paramstyle == "qmark":
@@ -976,10 +976,10 @@ class abstract_space_time_dataset(abstract_dataset):
 	else:
 	    sql = "INSERT INTO " + stds_register_table + " (id) " + "VALUES (%s);\n"
 
-        statement += dbif._mogrify_sql_statement((sql, (map_id,)), dbif)
+        statement += dbif.mogrify_sql_statement((sql, (map_id,)))
 
         # Now execute the insert transaction
-        execute_transaction(statement, dbif)
+        dbif.execute_transaction(statement)
 
         if connect == True:
             dbif.close()
@@ -1045,7 +1045,7 @@ class abstract_space_time_dataset(abstract_dataset):
             else:
                 sql = "DELETE FROM " + map_register_table + " WHERE id = %s;\n"
 
-            statement += dbif._mogrify_sql_statement((sql, (self.base.get_id(),)), dbif)
+            statement += dbif.mogrify_sql_statement((sql, (self.base.get_id(),)))
 
         # Remove the raster map from the space time raster dataset register
         if stds_register_table != None:
@@ -1054,10 +1054,10 @@ class abstract_space_time_dataset(abstract_dataset):
             else:
                 sql = "DELETE FROM " + stds_register_table + " WHERE id = %s;\n"
 
-            statement += dbif._mogrify_sql_statement((sql, (map_id,)), dbif)
+            statement += dbif.mogrify_sql_statement((sql, (map_id,)))
 
         if execute == True:
-            execute_transaction(statement, dbif)
+            dbif.execute_transaction(statement)
             
         if connect == True:
             dbif.close()
@@ -1127,7 +1127,7 @@ class abstract_space_time_dataset(abstract_dataset):
         sql_script += sql
         sql_script += "\n"
 
-	execute_transaction(sql_script, dbif)
+        dbif.execute_transaction(sql_script)
 	    
         # Read and validate the selected end time
         self.select()
@@ -1197,7 +1197,7 @@ class abstract_space_time_dataset(abstract_dataset):
                 sql = sql.replace("SPACETIME_ID", self.base.get_id())
                 sql = sql.replace("STDS", self.get_type())
 
-	    execute_transaction(sql, dbif)
+            dbif.execute_transaction(sql)
 
         # Count the temporal map types
         maps = self.get_registered_maps_as_objects(dbif=dbif)

lib/python/temporal/base.py

@@ -181,10 +181,7 @@ class sql_database_interface(dict_sql_serializer):
     """!This class represents the SQL database interface
 
        Functions to insert, select and update the internal structure of this class
-       in the temporal database are implemented. The following DBMS are supported:
-       * sqlite via the sqlite3 standard library
-       * postgresql via psycopg2
-
+       in the temporal database are implemented. 
        This is the base class for raster, raster3d, vector and space time datasets
        data management classes:
        * Identification information (base)
@@ -207,102 +204,25 @@ class sql_database_interface(dict_sql_serializer):
         """!Return the name of the table in which the internal data are inserted, updated or selected"""
         return self.table
 
-    def connect(self):
-        """!Connect to the DBMI to execute SQL statements
-
-           Supported backends are sqlite3 and postgresql
-        """
-        init = get_temporal_dbmi_init_string()
-        #print "Connect to",  self.database
-        if dbmi.__name__ == "sqlite3":
-	    self.connection = dbmi.connect(init, detect_types=dbmi.PARSE_DECLTYPES|dbmi.PARSE_COLNAMES)
-	    self.connection.row_factory = dbmi.Row
-            self.connection.isolation_level = None
-	    self.cursor = self.connection.cursor()
-            self.cursor.execute("PRAGMA synchronous = OFF")
-            self.cursor.execute("PRAGMA journal_mode = MEMORY")
-        elif dbmi.__name__ == "psycopg2":
-	    self.connection = dbmi.connect(init)
-	    #self.connection.set_isolation_level(dbmi.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
-	    self.cursor = self.connection.cursor(cursor_factory=dbmi.extras.DictCursor)
-
-    def close(self):
-        """!Close the DBMI connection"""
-        #print "Close connection to",  self.database
-	self.connection.commit()
-        self.cursor.close()
-
-
-    def _mogrify_sql_statement(self, content, dbif=None):
-        """!Return the SQL statement and arguments as executable SQL string
-        """
-        sql = content[0]
-        args = content[1]
-
-        if dbmi.__name__ == "psycopg2":
-            if len(args) == 0:
-                return sql
-            else:
-                if dbif:
-                    try:
-                        return dbif.cursor.mogrify(sql, args)
-                    except:
-                        print sql, args
-                        raise
-                else:
-                    self.connect()
-                    statement = self.cursor.mogrify(sql, args)
-                    self.close()
-                    return statement
-                    
-        elif dbmi.__name__ == "sqlite3":
-            if len(args) == 0:
-                return sql
-            else:
-                # Unfortunately as sqlite does not support 
-                # the transformation of sql strings and qmarked or
-                # named arguments we must make our hands dirty
-                # and do it by ourself. :(
-                # Doors are open for SQL injection because of the 
-                # limited python sqlite3 implementation!!!
-                pos = 0
-                count = 0
-                maxcount = 100
-                statement = sql
-
-                while count < maxcount:
-                    pos = statement.find("?", pos + 1)
-                    if pos == -1:
-                        break
-                    
-                    if args[count] == None:
-                        statement = "%sNULL%s"%(statement[0:pos], statement[pos+1:])
-                    elif isinstance(args[count], (int, long)):
-                        statement = "%s%d%s"%(statement[0:pos], args[count],statement[pos+1:])
-                    elif isinstance(args[count], float):
-                        statement = "%s%f%s"%(statement[0:pos], args[count],statement[pos+1:])
-                    else:
-                        # Default is a string, this works for datetime objects too
-                        statement = "%s\'%s\'%s"%(statement[0:pos], str(args[count]),statement[pos+1:])
-                    count += 1
-
-                return statement
-
     def get_delete_statement(self):
         """!Return the delete string"""
 	return "DELETE FROM " + self.get_table_name() + " WHERE id = \'" + str(self.ident) + "\';\n"
 
     def delete(self, dbif=None):
-        """!Delete the entry of this object from the temporal database"""
+        """!Delete the entry of this object from the temporal database
+
+           @param dbif: The database interface to be used, if None a temporary connection will be established
+        """
 	sql = self.get_delete_statement()
         #print sql
         
-        if dbif:
-            dbif.cursor.execute(sql)
-        else:
-            self.connect()
-            self.cursor.execute(sql)
-            self.close()
+	if dbif:
+	    dbif.cursor.execute(sql)
+	else:
+	    dbif = sql_database_interface_connection()
+	    dbif.connect()
+	    dbif.cursor.execute(sql)
+	    dbif.close()
 
     def get_is_in_db_statement(self):
         """Return the selection string"""
@@ -311,20 +231,21 @@ class sql_database_interface(dict_sql_serializer):
     def is_in_db(self, dbif=None):
         """!Check if this object is present in the temporal database
 
-           @param dbif: The database interface to be used
+           @param dbif: The database interface to be used, if None a temporary connection will be established
         """
 
 	sql = self.get_is_in_db_statement()
         #print sql
 
-        if dbif:
-            dbif.cursor.execute(sql)
-            row = dbif.cursor.fetchone()
-        else:
-            self.connect()
-            self.cursor.execute(sql)
-            row = self.cursor.fetchone()
-            self.close()
+	if dbif:
+	    dbif.cursor.execute(sql)
+	    row = dbif.cursor.fetchone()
+	else:
+	    dbif = sql_database_interface_connection()
+	    dbif.connect()
+	    dbif.cursor.execute(sql)
+	    row = dbif.cursor.fetchone()
+	    dbif.close()
 
 	# Nothing found
 	if row == None:
@@ -337,14 +258,20 @@ class sql_database_interface(dict_sql_serializer):
 	return self.serialize("SELECT", self.get_table_name(), "WHERE id = \'" + str(self.ident) + "\'")
     
     def get_select_statement_mogrified(self, dbif=None):
-        """!Return the select statement as mogrified string"""
-        return self._mogrify_sql_statement(self.get_select_statement(), dbif)
+        """!Return the select statement as mogrified string
+
+           @param dbif: The database interface to be used, if None a temporary connection will be established
+        """
+        if not dbif:
+	    dbif = sql_database_interface_connection()
+	    
+        return dbif.mogrify_sql_statement(self.get_select_statement())
                 
     def select(self, dbif=None):
         """!Select the content from the temporal database and store it
            in the internal dictionary structure
 
-           @param dbif: The database interface to be used
+           @param dbif: The database interface to be used, if None a temporary connection will be established
         """
 	sql, args = self.get_select_statement()
 	#print sql
@@ -357,13 +284,14 @@ class sql_database_interface(dict_sql_serializer):
                 dbif.cursor.execute(sql, args)
             row = dbif.cursor.fetchone()
         else:
-            self.connect()
-            if len(args) == 0:
-                self.cursor.execute(sql)
-            else:
-                self.cursor.execute(sql, args)
-            row = self.cursor.fetchone()
-            self.close()
+	    dbif = sql_database_interface_connection()
+	    dbif.connect()
+	    if len(args) == 0:
+		dbif.cursor.execute(sql)
+	    else:
+		dbif.cursor.execute(sql, args)
+	    row = dbif.cursor.fetchone()
+	    dbif.close()
 
 	# Nothing found
 	if row == None:
@@ -381,33 +309,46 @@ class sql_database_interface(dict_sql_serializer):
 	return self.serialize("INSERT", self.get_table_name())
     
     def get_insert_statement_mogrified(self, dbif=None):
-        """!Return the insert statement as mogrified string"""
-        return self._mogrify_sql_statement(self.get_insert_statement(), dbif)
+        """!Return the insert statement as mogrified string
+
+           @param dbif: The database interface to be used, if None a temporary connection will be established
+        """
+        if not dbif:
+	    dbif = sql_database_interface_connection()
+	    
+        return dbif.mogrify_sql_statement(self.get_insert_statement())
 
     def insert(self, dbif=None):
         """!Serialize the content of this object and store it in the temporal
            database using the internal identifier
 
-           @param dbif: The database interface to be used
+           @param dbif: The database interface to be used, if None a temporary connection will be established
         """
 	sql, args = self.get_insert_statement()
 	#print sql
 	#print args
 
-        if dbif:
-            dbif.cursor.execute(sql, args)
-        else:
-            self.connect()
-            self.cursor.execute(sql, args)
-            self.close()
+	if dbif:
+	    dbif.cursor.execute(sql, args)
+	else:
+	    dbif = sql_database_interface_connection()
+	    dbif.connect()
+	    dbif.cursor.execute(sql, args)
+	    dbif.close()
 
     def get_update_statement(self):
         """!Return the sql statement and the argument list in database specific style"""
 	return self.serialize("UPDATE", self.get_table_name(), "WHERE id = \'" + str(self.ident) + "\'")
 
     def get_update_statement_mogrified(self,dbif=None):
-        """!Return the update statement as mogrified string"""
-        return self._mogrify_sql_statement(self.get_update_statement(), dbif)
+        """!Return the update statement as mogrified string
+
+           @param dbif: The database interface to be used, if None a temporary connection will be established
+        """
+        if not dbif:
+	    dbif = sql_database_interface_connection()
+	    
+        return dbif.mogrify_sql_statement(self.get_update_statement())
 
     def update(self, dbif=None):
         """!Serialize the content of this object and update it in the temporal
@@ -415,7 +356,7 @@ class sql_database_interface(dict_sql_serializer):
 
            Only object entries which are exists (not None) are updated
 
-           @param dbif: The database interface to be used
+           @param dbif: The database interface to be used, if None a temporary connection will be established
         """
 	if self.ident == None:
 	    raise IOError("Missing identifer");
@@ -424,26 +365,33 @@ class sql_database_interface(dict_sql_serializer):
 	#print sql
 	#print args
 
-        if dbif:
-            dbif.cursor.execute(sql, args)
-        else:
-            self.connect()
-            self.cursor.execute(sql, args)
-            self.close()
+	if dbif:
+	    dbif.cursor.execute(sql, args)
+	else:
+	    dbif = sql_database_interface_connection()
+	    dbif.connect()
+	    dbif.cursor.execute(sql, args)
+	    dbif.close()
 
     def get_update_all_statement(self):
         """!Return the sql statement and the argument list in database specific style"""
 	return self.serialize("UPDATE ALL", self.get_table_name(), "WHERE id = \'" + str(self.ident) + "\'")
 
     def get_update_all_statement_mogrified(self, dbif=None):
-        """!Return the update all statement as mogrified string"""
-        return self._mogrify_sql_statement(self.get_update_all_statement(), dbif)
+        """!Return the update all statement as mogrified string
+
+           @param dbif: The database interface to be used, if None a temporary connection will be established
+        """
+        if not dbif:
+	    dbif = sql_database_interface_connection()
+	    
+        return dbif.mogrify_sql_statement(self.get_update_all_statement())
 
     def update_all(self, dbif=None):
         """!Serialize the content of this object, including None objects, and update it in the temporal
            database using the internal identifier
 
-           @param dbif: The database interface to be used
+           @param dbif: The database interface to be used, if None a temporary connection will be established
         """
 	if self.ident == None:
 	    raise IOError("Missing identifer");
@@ -452,12 +400,13 @@ class sql_database_interface(dict_sql_serializer):
 	#print sql
 	#print args
 
-        if dbif:
-            dbif.cursor.execute(sql, args)
-        else:
-            self.connect()
-            self.cursor.execute(sql, args)
-            self.close()
+	if dbif:
+	    dbif.cursor.execute(sql, args)
+	else:
+	    dbif = sql_database_interface_connection()
+	    dbif.connect()
+	    dbif.cursor.execute(sql, args)
+	    dbif.close()
 
 ###############################################################################
 
@@ -754,52 +703,4 @@ class stvds_base(stds_base):
         stds_base.__init__(self, "stvds_base", ident, name, mapset, semantic_type, creator, creation_time,\
 	            modification_time, temporal_type, revision)
 
-###############################################################################
-
-def init_dbif(dbif):
-    """!This method checks if the database interface exists, if not a new one 
-        will be created and True will be returned
-
-        Usage code sample:
-        dbif, connect = self._init_dbif(dbif)
-        if connect:
-            dbif.close()
-    """
-    if dbif == None:
-        dbif = sql_database_interface()
-        dbif.connect()
-        return dbif, True
-
-    return dbif, False
 
-###############################################################################
-
-def execute_transaction(statement, dbif=None):
-    """!Execute a transactional SQL statement
-
-        The BEGIN and END TRANSACTION statements will be added automatically
-        to the sql statement
-
-        @param statement The executable SQL statement or SQL script
-        @param dbif The database interface, if None a new db interface will be created temporary
-    """
-    dbif, connect = init_dbif(dbif)
-
-    sql_script = ""
-    sql_script += "BEGIN TRANSACTION;\n"
-    sql_script += statement
-    sql_script += "END TRANSACTION;"
-    try:
-        if dbmi.__name__ == "sqlite3":
-            dbif.cursor.executescript(statement)
-        else:
-            dbif.cursor.execute(statement)
-        dbif.connection.commit()
-    except:
-        if connect == True:
-            dbif.close()
-        core.error(_("Unable to execute transaction:\n %s") % (statement))
-        raise
-
-    if connect:
-        dbif.close()

lib/python/temporal/core.py

@@ -167,3 +167,148 @@ def create_temporal_database():
 
     connection.commit()
     cursor.close()
+
+###############################################################################
+
+class sql_database_interface_connection():
+    """!This class represents the database interface connection
+    
+       The following DBMS are supported:
+       * sqlite via the sqlite3 standard library
+       * postgresql via psycopg2
+
+    """
+    def __init__(self):
+	self.connected = False
+	
+    def connect(self):
+        """!Connect to the DBMI to execute SQL statements
+
+           Supported backends are sqlite3 and postgresql
+        """
+        init = get_temporal_dbmi_init_string()
+        #print "Connect to",  self.database
+        if dbmi.__name__ == "sqlite3":
+	    self.connection = dbmi.connect(init, detect_types=dbmi.PARSE_DECLTYPES|dbmi.PARSE_COLNAMES)
+	    self.connection.row_factory = dbmi.Row
+            self.connection.isolation_level = None
+	    self.cursor = self.connection.cursor()
+            self.cursor.execute("PRAGMA synchronous = OFF")
+            self.cursor.execute("PRAGMA journal_mode = MEMORY")
+        elif dbmi.__name__ == "psycopg2":
+	    self.connection = dbmi.connect(init)
+	    #self.connection.set_isolation_level(dbmi.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
+	    self.cursor = self.connection.cursor(cursor_factory=dbmi.extras.DictCursor)
+	self.connected = True
+	
+    def close(self):
+        """!Close the DBMI connection"""
+        #print "Close connection to",  self.database
+	self.connection.commit()
+        self.cursor.close()
+	self.connected = False
+
+    def mogrify_sql_statement(self, content):
+        """!Return the SQL statement and arguments as executable SQL string
+        """
+        sql = content[0]
+        args = content[1]
+
+        if dbmi.__name__ == "psycopg2":
+            if len(args) == 0:
+                return sql
+            else:
+                if self.connected:
+                    try:
+                        return self.cursor.mogrify(sql, args)
+                    except:
+                        print sql, args
+                        raise
+                else:
+                    self.connect()
+                    statement = self.cursor.mogrify(sql, args)
+                    self.close()
+                    return statement
+                    
+        elif dbmi.__name__ == "sqlite3":
+            if len(args) == 0:
+                return sql
+            else:
+                # Unfortunately as sqlite does not support 
+                # the transformation of sql strings and qmarked or
+                # named arguments we must make our hands dirty
+                # and do it by ourself. :(
+                # Doors are open for SQL injection because of the 
+                # limited python sqlite3 implementation!!!
+                pos = 0
+                count = 0
+                maxcount = 100
+                statement = sql
+
+                while count < maxcount:
+                    pos = statement.find("?", pos + 1)
+                    if pos == -1:
+                        break
+                    
+                    if args[count] == None:
+                        statement = "%sNULL%s"%(statement[0:pos], statement[pos+1:])
+                    elif isinstance(args[count], (int, long)):
+                        statement = "%s%d%s"%(statement[0:pos], args[count],statement[pos+1:])
+                    elif isinstance(args[count], float):
+                        statement = "%s%f%s"%(statement[0:pos], args[count],statement[pos+1:])
+                    else:
+                        # Default is a string, this works for datetime objects too
+                        statement = "%s\'%s\'%s"%(statement[0:pos], str(args[count]),statement[pos+1:])
+                    count += 1
+
+                return statement
+                
+    def execute_transaction(self, statement):
+	"""!Execute a transactional SQL statement
+
+	    The BEGIN and END TRANSACTION statements will be added automatically
+	    to the sql statement
+
+	    @param statement The executable SQL statement or SQL script
+	"""
+	connect = False
+	if self.connected == False:
+	    self.connect()
+	    connect = True
+
+	sql_script = ""
+	sql_script += "BEGIN TRANSACTION;\n"
+	sql_script += statement
+	sql_script += "END TRANSACTION;"
+	try:
+	    if dbmi.__name__ == "sqlite3":
+		self.cursor.executescript(statement)
+	    else:
+		self.cursor.execute(statement)
+	    self.connection.commit()
+	except:
+	    if connect == True:
+		self.close()
+	    core.error(_("Unable to execute transaction:\n %s") % (statement))
+	    raise
+
+	if connect:
+	    self.close()
+	    
+###############################################################################
+
+def init_dbif(dbif):
+    """!This method checks if the database interface connection exists, if not a new one 
+        will be created, connected and True will be returned
+
+        Usage code sample:
+        dbif, connect = tgis.init_dbif(dbif)
+        if connect:
+            dbif.close()
+    """
+    if dbif == None:
+        dbif = sql_database_interface_connection()
+        dbif.connect()
+        return dbif, True
+
+    return dbif, False

lib/python/temporal/space_time_datasets.py

@@ -25,6 +25,11 @@ import getpass
 import grass.script.raster as raster
 import grass.script.vector as vector
 import grass.script.raster3d as raster3d
+
+from ctypes import *
+import grass.lib.gis as libgis
+import grass.lib.raster as libraster
+
 from datetime_math import *
 from abstract_map_dataset import *
 from abstract_space_time_dataset import *
@@ -59,10 +64,6 @@ class raster_dataset(abstract_map_dataset):
     def set_stds_register(self, name):
         """!Set the space time dataset register table name in which stds are listed in which this map is registered"""
         self.metadata.set_strds_register(name)
- 
-    def get_timestamp_module_name(self):
-        """!Return the name of the C-module to set the time stamp in the file system"""
-        return "r.timestamp"
 
     def spatial_overlapping(self, dataset):
         """!Return True if the spatial extents 2d overlap"""
@@ -83,12 +84,119 @@ class raster_dataset(abstract_map_dataset):
 	self.relative_time = raster_relative_time(ident=ident)
 	self.spatial_extent = raster_spatial_extent(ident=ident)
 	self.metadata = raster_metadata(ident=ident)
+		
+    def has_grass_timestamp(self):
+        """!Check if a grass file bsased time stamp exists for this map. 
+        """
+        if G_has_raster_timestamp(self.get_name(), self.get_mapset()):
+	    return True
+	else:
+	    return False
+ 
+    def write_timestamp_to_grass(self):
+        """!Write the timestamp of this map into the map metadata in the grass file system based spatial
+           database. 
+           
+           Internally the libgis API functions are used for writing
+        """
+        
+	ts = libgis.TimeStamp()
+
+	libgis.G_scan_timestamp(byref(ts), self._convert_timestamp())
+	check = libgis.G_write_raster_timestamp(self.get_name(), byref(ts))
+	
+	if check == -1:
+		core.error(_("Unable to create timestamp file for raster map <%s>"%(self.get_map_id())))
+		
+	if check == -2:
+		core.error(_("Invalid datetime in timestamp for raster map <%s>"%(self.get_map_id())))
+			
+    
+    def remove_timestamp_from_grass(self):
+        """!Remove the timestamp from the grass file system based spatial database
+        
+           Internally the libgis API functions are used for removal
+        """
+        check = libgis.G_remove_raster_timestamp(self.get_name())
+        
+        if check == -1:
+            core.error(_("Unable to remove timestamp for raster map <%s>"%(self.get_name())))
+	
+    def map_exists(self):
+        """!Return True in case the map exists in the grass spatial database
+        
+           @return True if map exists, False otherwise
+        """        
+        mapset = libgis.G_find_raster(self.get_name(), self.get_mapset())
+        
+        if not mapset:
+            return False
+	
+	return True
+        
+    def read_info(self):
+        """!Read the raster map info from the file system and store the content 
+           into a dictionary
+           
+           This method uses the ctypes interface to the gis and raster libraries
+           to read the map metadata information
+        """
+        
+        kvp = {}
+        
+        name = self.get_name()
+        mapset = self.get_mapset()
+        
+        if not self.map_exists():
+	  core.fatal(_("Raster map <%s> not found" % name))
+        
+        # Read the region information
+        region = libgis.Cell_head()
+	libraster.Rast_get_cellhd(name, mapset, byref(region))
+	
+	kvp["north"] = region.north
+	kvp["south"] = region.south
+	kvp["east"] = region.east
+	kvp["west"] = region.west
+	kvp["nsres"] = region.ns_res
+	kvp["ewres"] = region.ew_res
+	kvp["rows"] = region.cols
+	kvp["cols"] = region.rows
+	
+	maptype = libraster.Rast_map_type(name, mapset)
+  
+	if maptype == libraster.DCELL_TYPE:
+	    kvp["datatype"] = "DCELL"
+        elif maptype == libraster.FCELL_TYPE:
+	    kvp["datatype"] = "FCELL"
+        elif maptype == libraster.CELL_TYPE:
+	    kvp["datatype"] = "CELL"
+	    
+	# Read range
+	if libraster.Rast_map_is_fp(name, mapset):
+	    range = libraster.FPRange()
+	    libraster.Rast_init_fp_range (byref(range))
+	    libraster.Rast_read_fp_range(name, mapset, byref(range))
+	    min = libgis.DCELL()
+	    max = libgis.DCELL()
+	    libraster.Rast_get_fp_range_min_max(byref(range), byref(min), byref(max))
+	    kvp["min"] = float(min.value)
+	    kvp["max"] = float(max.value)
+	else:
+	    range = libraster.Range()
+	    libraster.Rast_init_range (byref(range))
+	    libraster.Rast_read_range(name, mapset, byref(range))
+	    min = libgis.CELL()
+	    max = libgis.CELL()
+	    libraster.Rast_get_fp_range_min_max(byref(range), byref(min), byref(max))
+	    kvp["min"] = int(min.value)
+	    kvp["max"] = int(max.value)
+	
+	return kvp
 
     def load(self):
         """!Load all info from an existing raster map into the internal structure"""
 
-        # Get the data from an existing raster map
-        kvp = raster.raster_info(self.get_map_id())
 
         # Fill base information
 
@@ -96,6 +204,9 @@ class raster_dataset(abstract_map_dataset):
         self.base.set_mapset(self.ident.split("@")[1])
         self.base.set_creator(str(getpass.getuser()))
 
+        # Get the data from an existing raster map
+        kvp = self.read_info()
+        
         # Fill spatial extent
 
         self.set_spatial_extent(north=kvp["north"], south=kvp["south"], \
@@ -109,8 +220,8 @@ class raster_dataset(abstract_map_dataset):
         self.metadata.set_min(kvp["min"])
         self.metadata.set_max(kvp["max"])
 
-        rows = int((kvp["north"] - kvp["south"])/kvp["nsres"] + 0.5)
-        cols = int((kvp["east"] - kvp["west"])/kvp["ewres"] + 0.5)
+        rows = kvp["rows"]
+        cols = kvp["cols"]
 
         ncells = cols * rows
 
@@ -147,10 +258,6 @@ class raster3d_dataset(abstract_map_dataset):
     def set_stds_register(self, name):
         """!Set the space time dataset register table name in which stds are listed in which this map is registered"""
         self.metadata.set_str3ds_register(name)
- 
-    def get_timestamp_module_name(self):
-        """!Return the name of the C-module to set the time stamp in the file system"""
-        return "r3.timestamp"
 
     def spatial_overlapping(self, dataset):
         """!Return True if the spatial extents overlap"""
@@ -178,6 +285,55 @@ class raster3d_dataset(abstract_map_dataset):
 	self.spatial_extent = raster3d_spatial_extent(ident=ident)
 	self.metadata = raster3d_metadata(ident=ident)
 
+    def has_grass_timestamp(self):
+        """!Check if a grass file bsased time stamp exists for this map. 
+        """
+        if G_has_raster3d_timestamp(self.get_name(), self.get_mapset()):
+	    return True
+	else:
+	    return False
+ 
+    def write_timestamp_to_grass(self):
+        """!Write the timestamp of this map into the map metadata in the grass file system based spatial
+           database. 
+           
+           Internally the libgis API functions are used for writing
+        """
+        
+	ts = libgis.TimeStamp()
+
+	libgis.G_scan_timestamp(byref(ts), self._convert_timestamp())
+	check = libgis.G_write_raster3d_timestamp(self.get_name(), byref(ts))
+	
+	if check == -1:
+		core.error(_("Unable to create timestamp file for raster3d map <%s>"%(self.get_map_id())))
+		
+	if check == -2:
+		core.error(_("Invalid datetime in timestamp for raster3d map <%s>"%(self.get_map_id())))
+			
+    
+    def remove_timestamp_from_grass(self):
+        """!Remove the timestamp from the grass file system based spatial database
+        
+           Internally the libgis API functions are used for removal
+        """
+        check = libgis.G_remove_raster3d_timestamp(self.get_name())
+        
+        if check == -1:
+            core.error(_("Unable to remove timestamp for raster3d map <%s>"%(self.get_name())))
+	
+    def map_exists(self):
+        """!Return True in case the map exists in the grass spatial database
+        
+           @return True if map exists, False otherwise
+        """        
+        mapset = libgis.G_find_raster3d(self.get_name(), self.get_mapset())
+        
+        if not mapset:
+            return False
+	
+	return True
+        
     def load(self):
         """!Load all info from an existing raster3d map into the internal structure"""
 
@@ -245,10 +401,6 @@ class vector_dataset(abstract_map_dataset):
     def set_stds_register(self, name):
         """!Set the space time dataset register table name in which stds are listed in which this map is registered"""
         self.metadata.set_stvds_register(name)
- 
-    def get_timestamp_module_name(self):
-        """!Return the name of the C-module to set the time stamp in the file system"""
-        return "v.timestamp"
 
     def get_layer(self):
         """!Return the layer"""
@@ -264,7 +416,6 @@ class vector_dataset(abstract_map_dataset):
         
         return self.spatial_extent.spatial_relation_2d(dataset.spatial_extent)
 	
-
     def reset(self, ident):
 	"""!Reset the internal structure and set the identifier"""
 	self.ident = ident
@@ -275,6 +426,55 @@ class vector_dataset(abstract_map_dataset):
 	self.spatial_extent = vector_spatial_extent(ident=ident)
 	self.metadata = vector_metadata(ident=ident)
 
+    def has_grass_timestamp(self):
+        """!Check if a grass file bsased time stamp exists for this map. 
+        """
+        if G_has_raster_timestamp(self.get_name(), self.get_layer(), self.get_mapset()):
+	    return True
+	else:
+	    return False
+ 
+    def write_timestamp_to_grass(self):
+        """!Write the timestamp of this map into the map metadata in the grass file system based spatial
+           database. 
+           
+           Internally the libgis API functions are used for writing
+        """
+        
+	ts = libgis.TimeStamp()
+
+	libgis.G_scan_timestamp(byref(ts), self._convert_timestamp())
+	check = libgis.G_write_vector_timestamp(self.get_name(), self.get_layer(), byref(ts))
+	
+	if check == -1:
+		core.error(_("Unable to create timestamp file for vector map <%s>"%(self.get_map_id())))
+		
+	if check == -2:
+		core.error(_("Invalid datetime in timestamp for vector map <%s>"%(self.get_map_id())))
+			
+    
+    def remove_timestamp_from_grass(self):
+        """!Remove the timestamp from the grass file system based spatial database
+        
+           Internally the libgis API functions are used for removal
+        """
+        check = libgis.G_remove_vector_timestamp(self.get_name(), self.get_layer())
+        
+        if check == -1:
+            core.error(_("Unable to remove timestamp for vector map <%s>"%(self.get_name())))
+	
+    def map_exists(self):
+        """!Return True in case the map exists in the grass spatial database
+        
+           @return True if map exists, False otherwise
+        """        
+        mapset = libgis.G_find_vector(self.get_name(), self.get_mapset())
+        
+        if not mapset:
+            return False
+	
+	return True
+        
     def load(self):
         """!Load all info from an existing vector map into the internal structure"""
 

lib/python/temporal/space_time_datasets_tools.py

@@ -218,7 +218,7 @@ def register_maps_in_space_time_dataset(type, name, maps=None, file=None, start=
 
         if is_in_db:
            #  Gather the SQL update statement
-           statement += map.update_all(dbif=dbif, execute=True)
+           statement += map.update_all(dbif=dbif, execute=False)
         else:
            #  Gather the SQL insert statement
            statement += map.insert(dbif=dbif, execute=False)
@@ -227,8 +227,8 @@ def register_maps_in_space_time_dataset(type, name, maps=None, file=None, start=
         if dbmi.__name__ == "sqlite3":
             if count % 100 == 0:
                 if statement != None and statement != "":
-                    core.message(_("Registering 100 maps in the temporal database"))
-                    execute_transaction(statement, dbif)
+                    core.message(_("Registering maps in the temporal database"))
+		    dbif.execute_transaction(statement)
                     statement = ""
 
         # Store the maps in a list to register in a space time dataset
@@ -239,7 +239,7 @@ def register_maps_in_space_time_dataset(type, name, maps=None, file=None, start=
 
     if statement != None and statement != "":
         core.message(_("Register maps in the temporal database"))
-        execute_transaction(statement, dbif)
+        dbif.execute_transaction(statement)
 
     # Finally Register the maps in the space time dataset
     if name:
@@ -534,7 +534,7 @@ def sample_stds_by_stds_topology(intype, sampletype, inputs, sampler, header, se
 
     sst = dataset_factory(sampletype, sid)
 
-    dbif = sql_database_interface()
+    dbif = sql_database_interface_connection()
     dbif.connect()
 
     for st in sts:

temporal/t.create/t.create.py

@@ -80,7 +80,7 @@ def main():
 
     sp = tgis.dataset_factory(type, id)
 
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
 
     if sp.is_in_db(dbif) and grass.overwrite() == False:

temporal/t.list/t.list.py

@@ -89,7 +89,7 @@ def main():
     id = None
     sp = tgis.dataset_factory(type, id)
 
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
 
     # Create the sql selection statement

temporal/t.rast.aggregate.ds/t.rast.aggregate.ds.py

@@ -81,7 +81,7 @@ def main():
     # Make sure the temporal database exists
     tgis.create_temporal_database()
     # We need a database interface
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
    
     mapset =  grass.gisenv()["MAPSET"]

temporal/t.rast.aggregate/t.rast.aggregate.py

@@ -94,7 +94,7 @@ def main():
     # Make sure the temporal database exists
     tgis.create_temporal_database()
     # We need a database interface
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
    
     mapset =  grass.gisenv()["MAPSET"]

temporal/t.rast.extract/t.rast.extract.py

@@ -83,15 +83,17 @@ def main():
 
     sp = tgis.space_time_raster_dataset(id)
     
-    if sp.is_in_db() == False:
+    dbif = tgis.sql_database_interface_connection()
+    dbif.connect()
+    
+    if sp.is_in_db(dbif) == False:
+	dbif.close()
         grass.fatal(_("Space time %s dataset <%s> not found") % (sp.get_new_map_instance(None).get_type(), id))
 
     if expression and not base:
+	dbif.close()
         grass.fatal(_("Please specify base="))
 
-    dbif = tgis.sql_database_interface()
-    dbif.connect()
-
     sp.select(dbif)
 
     if output.find("@") >= 0:
@@ -103,6 +105,7 @@ def main():
     new_sp = tgis.space_time_raster_dataset(out_id)
     if new_sp.is_in_db():
         if grass.overwrite() == False:
+	    dbif.close()
             grass.fatal(_("Space time raster dataset <%s> is already in database, use overwrite flag to overwrite") % out_id)
             
     rows = sp.get_registered_maps("id", where, "start_time", dbif)
@@ -156,6 +159,7 @@ def main():
 			exitcodes += proc.exitcode
 			
 		    if exitcodes != 0:
+			dbif.close()
 			grass.fatal(_("Error while r.mapcalc computation"))
 			
 		    # Empty proc list

temporal/t.rast.mapcalc/t.rast.mapcalc.py

@@ -88,7 +88,7 @@ def main():
     tgis.create_temporal_database()
     
     # We need a database interface for fast computation
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
 
     mapset =  grass.gisenv()["MAPSET"]

temporal/t.rast.univar/t.rast.univar.py

@@ -62,7 +62,7 @@ def main():
     # Make sure the temporal database exists
     tgis.create_temporal_database()
     # We need a database interface
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
    
     mapset =  grass.gisenv()["MAPSET"]

temporal/t.rast3d.extract/t.rast3d.extract.py

@@ -83,7 +83,7 @@ def main():
     if sp.is_in_db() == False:
         grass.fatal(_("Space time %s dataset <%s> not found") % (sp.get_new_map_instance(None).get_type(), id))
 
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
 
     sp.select(dbif)

temporal/t.remove/t.remove.py

@@ -46,10 +46,6 @@ import grass.temporal as tgis
 
 ############################################################################
 
-#
-# TODO: Add recursive and physical removement of maps and datasets
-#
-
 def main():
     
     # Get the options
@@ -63,7 +59,7 @@ def main():
     # Make sure the temporal database exists
     tgis.create_temporal_database()
 
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
 
     dataset_list = []
@@ -110,7 +106,7 @@ def main():
         statement += sp.delete(dbif=dbif, execute=False)
 
     # Execute the collected SQL statenents
-    tgis.execute_transaction(statement, dbif)
+    dbif.execute_transaction(statement)
 
     dbif.close()
 

temporal/t.support/t.support.py

@@ -89,7 +89,7 @@ def main():
     else:
         id = name + "@" + mapset
         
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
 
     sp = tgis.dataset_factory(type, id)

temporal/t.unregister/t.unregister.py

@@ -63,7 +63,7 @@ def main():
 
     mapset =  grass.gisenv()["MAPSET"]
 
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
 
     # In case a space time dataset is specified
@@ -152,7 +152,7 @@ def main():
 	count += 1
 
     # Execute the collected SQL statenents
-    tgis.execute_transaction(statement, dbif)
+    dbif.execute_transaction(statement)
 	
     grass.percent(num_maps, num_maps, 1)
 

temporal/t.vect.observe.strds/t.vect.observe.strds.py

@@ -76,7 +76,7 @@ def main():
     # Make sure the temporal database exists
     tgis.create_temporal_database()
     # We need a database interface
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
    
     mapset =  grass.gisenv()["MAPSET"]
@@ -107,8 +107,8 @@ def main():
 
     # Overwrite existing stvds
     if out_sp.is_in_db(dbif) == True and grass.overwrite() == True:
-        out_sp.select()
-        out_sp.delete()
+        out_sp.select(dbif)
+        out_sp.delete(dbif)
         out_sp = tgis.space_time_vector_dataset(id)
 
     # Select the raster maps
@@ -122,8 +122,8 @@ def main():
 
     out_sp.set_initial_values(strds_sp.get_temporal_type(), \
                               strds_sp.get_semantic_type(),\
-                              _("Observation of space time raster dataset <%s>")%(strds_id),\
-                              _("Observattion of space time raster dataset <%s> with vector map <%s>")%(strds_id, input))
+                              _("Observaion of space time raster dataset <%s>")%(strds_id),\
+                              _("Observation of space time raster dataset <%s> with vector map <%s>")%(strds_id, input))
 
     out_sp.insert(dbif)
 
@@ -192,7 +192,7 @@ def main():
         else:
             vect.set_relative_time(start, end, strds_ds.get_relative_time_unit())
        
-        if vect.is_in_db():
+        if vect.is_in_db(dbif):
             vect.update(dbif)
         else:
             vect.insert(dbif)

temporal/t.vect.observe.strds/test.t.vect.observe.strds.sh

@@ -17,7 +17,7 @@ t.create --o type=strds temporaltype=absolute output=precip_abs1 title="A test"
 t.register -i input=precip_abs1 maps=prec_1,prec_2,prec_3,prec_4,prec_5,prec_6 start="2001-03-01 00:00:00" increment="1 months"
 
 # The @test
-tv.observe.strds input=prec strds=precip_abs1 output=prec_observer 
+t.vect.observe.strds input=prec strds=precip_abs1 output=prec_observer 
 v.info prec_observer
 t.info type=stvds input=prec_observer
 

temporal/t.vect.what.strds/t.vect.what.strds.py

@@ -68,7 +68,7 @@ def main():
     # Make sure the temporal database exists
     tgis.create_temporal_database()
     # We need a database interface
-    dbif = tgis.sql_database_interface()
+    dbif = tgis.sql_database_interface_connection()
     dbif.connect()
    
     mapset =  grass.gisenv()["MAPSET"]