fix sqlite cdr build with new sqlite wrapper in the core, exposing all the…

fix sqlite cdr build with new sqlite wrapper in the core, exposing all the necessary functions.  Add sqlite cdr to the windows build.

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@4505 d0543943-73ff-0310-b7d9-9358b9ac24b2

src/include/switch_core_db.h

@@ -59,6 +59,22 @@ typedef struct sqlite3_stmt switch_core_db_stmt_t;
 
 typedef int (*switch_core_db_callback_func_t)(void *pArg, int argc, char **argv, char **columnNames);
 
+/*
+** These are special value for the destructor that is passed in as the
+** final argument to routines like switch_core_db_result_blob().  If the destructor
+** argument is SWITCH_CORE_DB_STATIC, it means that the content pointer is constant
+** and will never change.  It does not need to be destroyed.  The 
+** SWITCH_CORE_DB_TRANSIENT value means that the content will likely change in
+** the near future and that the db should make its own private copy of
+** the content before returning.
+**
+** The typedef is necessary to work around problems in certain
+** C++ compilers.
+*/
+typedef void (*switch_core_db_destructor_type_t)(void*);
+#define SWITCH_CORE_DB_STATIC      ((switch_core_db_destructor_type_t)0)
+#define SWITCH_CORE_DB_TRANSIENT   ((switch_core_db_destructor_type_t)-1)
+
 /**
  * A function to close the database.
  *
@@ -278,6 +294,177 @@ SWITCH_DECLARE(int) switch_core_db_prepare(switch_core_db_t *db,
  */
 SWITCH_DECLARE(int) switch_core_db_step(switch_core_db_stmt_t *stmt);
 
+/**
+ * The switch_core_db_reset() function is called to reset a compiled SQL
+ * statement obtained by a previous call to switch_core_db_prepare()
+ * back to it's initial state, ready to be re-executed.
+ * Any SQL statement variables that had values bound to them using
+ * the switch_core_db_bind_*() API retain their values.
+ */
+SWITCH_DECLARE(int) switch_core_db_reset(switch_core_db_stmt_t *pStmt);
+
+/**
+ * In the SQL strings input to switch_core_db_prepare(),
+ * one or more literals can be replace by parameters "?" or ":AAA" or
+ * "$VVV" where AAA is an identifer and VVV is a variable name according
+ * to the syntax rules of the TCL programming language.
+ * The value of these parameters (also called "host parameter names") can
+ * be set using the routines listed below.
+ *
+ * In every case, the first parameter is a pointer to the sqlite3_stmt
+ * structure returned from switch_core_db_prepare().  The second parameter is the
+ * index of the parameter.  The first parameter as an index of 1.  For
+ * named parameters (":AAA" or "$VVV") you can use 
+ * switch_core_db_bind_parameter_index() to get the correct index value given
+ * the parameters name.  If the same named parameter occurs more than
+ * once, it is assigned the same index each time.
+ *
+ * The switch_core_db_bind_* routine must be called before switch_core_db_step() after
+ * an switch_core_db_prepare() or sqlite3_reset().  Unbound parameterss are
+ * interpreted as NULL.
+ */
+SWITCH_DECLARE(int) switch_core_db_bind_int(switch_core_db_stmt_t *pStmt, int i, int iValue);
+
+/**
+ * In the SQL strings input to switch_core_db_prepare(),
+ * one or more literals can be replace by parameters "?" or ":AAA" or
+ * "$VVV" where AAA is an identifer and VVV is a variable name according
+ * to the syntax rules of the TCL programming language.
+ * The value of these parameters (also called "host parameter names") can
+ * be set using the routines listed below.
+ *
+ * In every case, the first parameter is a pointer to the sqlite3_stmt
+ * structure returned from switch_core_db_prepare().  The second parameter is the
+ * index of the parameter.  The first parameter as an index of 1.  For
+ * named parameters (":AAA" or "$VVV") you can use 
+ * switch_core_db_bind_parameter_index() to get the correct index value given
+ * the parameters name.  If the same named parameter occurs more than
+ * once, it is assigned the same index each time.
+ *
+ * The switch_core_db_bind_* routine must be called before switch_core_db_step() after
+ * an switch_core_db_prepare() or sqlite3_reset().  Unbound parameterss are
+ * interpreted as NULL.
+ */
+SWITCH_DECLARE(int) switch_core_db_bind_int64(switch_core_db_stmt_t *pStmt, int i, int64_t iValue);
+
+/**
+ * In the SQL strings input to switch_core_db_prepare(),
+ * one or more literals can be replace by parameters "?" or ":AAA" or
+ * "$VVV" where AAA is an identifer and VVV is a variable name according
+ * to the syntax rules of the TCL programming language.
+ * The value of these parameters (also called "host parameter names") can
+ * be set using the routines listed below.
+ *
+ * In every case, the first parameter is a pointer to the sqlite3_stmt
+ * structure returned from switch_core_db_prepare().  The second parameter is the
+ * index of the parameter.  The first parameter as an index of 1.  For
+ * named parameters (":AAA" or "$VVV") you can use 
+ * switch_core_db_bind_parameter_index() to get the correct index value given
+ * the parameters name.  If the same named parameter occurs more than
+ * once, it is assigned the same index each time.
+ *
+ * The fifth parameter to switch_core_db_bind_blob(), switch_core_db_bind_text(), and
+ * switch_core_db_bind_text16() is a destructor used to dispose of the BLOB or
+ * text after SQLite has finished with it.  If the fifth argument is the
+ * special value SQLITE_STATIC, then the library assumes that the information
+ * is in static, unmanaged space and does not need to be freed.  If the
+ * fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its
+ * own private copy of the data.
+ *
+ * The switch_core_db_bind_* routine must be called before switch_core_db_step() after
+ * an switch_core_db_prepare() or sqlite3_reset().  Unbound parameterss are
+ * interpreted as NULL.
+ */
+SWITCH_DECLARE(int) switch_core_db_bind_text(switch_core_db_stmt_t *pStmt, int i, const char *zData, int nData, switch_core_db_destructor_type_t xDel);
+
+/**
+ * In the SQL strings input to switch_core_db_prepare(),
+ * one or more literals can be replace by parameters "?" or ":AAA" or
+ * "$VVV" where AAA is an identifer and VVV is a variable name according
+ * to the syntax rules of the TCL programming language.
+ * The value of these parameters (also called "host parameter names") can
+ * be set using the routines listed below.
+ *
+ * In every case, the first parameter is a pointer to the sqlite3_stmt
+ * structure returned from switch_core_db_prepare().  The second parameter is the
+ * index of the parameter.  The first parameter as an index of 1.  For
+ * named parameters (":AAA" or "$VVV") you can use 
+ * sqlite3_bind_parameter_index() to get the correct index value given
+ * the parameters name.  If the same named parameter occurs more than
+ * once, it is assigned the same index each time.
+ *
+ * The sqlite3_bind_* routine must be called before switch_core_db_step() after
+ * an switch_core_db_prepare() or switch_core_db_reset().  Unbound parameterss are
+ * interpreted as NULL.
+ */
+SWITCH_DECLARE(int) switch_core_db_bind_double(switch_core_db_stmt_t *pStmt, int i, double dValue);
+
+/**
+ * Each entry in a table has a unique integer key.  (The key is
+ * the value of the INTEGER PRIMARY KEY column if there is such a column,
+ * otherwise the key is generated at random.  The unique key is always
+ * available as the ROWID, OID, or _ROWID_ column.)  The following routine
+ * returns the integer key of the most recent insert in the database.
+ *
+ * This function is similar to the mysql_insert_id() function from MySQL.
+ */
+SWITCH_DECLARE(int64_t) switch_core_db_last_insert_rowid(switch_core_db_t *db);
+
+/**
+ * This next routine is really just a wrapper around switch_core_db_exec().
+ * Instead of invoking a user-supplied callback for each row of the
+ * result, this routine remembers each row of the result in memory
+ * obtained from malloc(), then returns all of the result after the
+ * query has finished. 
+ *
+ * As an example, suppose the query result where this table:
+ *
+ *        Name        | Age
+ *        -----------------------
+ *        Alice       | 43
+ *        Bob         | 28
+ *        Cindy       | 21
+ *
+ * If the 3rd argument were &azResult then after the function returns
+ * azResult will contain the following data:
+ *
+ *        azResult[0] = "Name";
+ *        azResult[1] = "Age";
+ *        azResult[2] = "Alice";
+ *        azResult[3] = "43";
+ *        azResult[4] = "Bob";
+ *        azResult[5] = "28";
+ *        azResult[6] = "Cindy";
+ *        azResult[7] = "21";
+ *
+ * Notice that there is an extra row of data containing the column
+ * headers.  But the *nrow return value is still 3.  *ncolumn is
+ * set to 2.  In general, the number of values inserted into azResult
+ * will be ((*nrow) + 1)*(*ncolumn).
+ *
+ * After the calling function has finished using the result, it should 
+ * pass the result data pointer to switch_core_db_free_table() in order to 
+ * release the memory that was malloc-ed.  Because of the way the 
+ * malloc() happens, the calling function must not try to call 
+ * free() directly.  Only switch_core_db_free_table() is able to release 
+ * the memory properly and safely.
+ *
+ * The return value of this routine is the same as from switch_core_db_exec().
+ */
+SWITCH_DECLARE(int) switch_core_db_get_table(
+  switch_core_db_t *db,       /* An open database */
+  const char *sql,       /* SQL to be executed */
+  char ***resultp,       /* Result written to a char *[]  that this points to */
+  int *nrow,             /* Number of result rows written here */
+  int *ncolumn,          /* Number of result columns written here */
+  char **errmsg          /* Error msg written here */
+);
+
+/**
+ * Call this routine to free the memory that sqlite3_get_table() allocated.
+ */
+SWITCH_DECLARE(void) switch_core_db_free_table(char **result);
+
 /**
  * Call this routine to free the memory that switch_core_db_get_table() allocated.
  */

src/mod/event_handlers/mod_cdr/mod_cdr.vcproj

@@ -396,6 +396,10 @@
 				RelativePath=".\pddcdr.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\sqlitecdr.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\xmlcdr.cpp"
 				>
@@ -430,6 +434,10 @@
 				RelativePath=".\pddcdr.h"
 				>
 			</File>
+			<File
+				RelativePath=".\sqlitecdr.h"
+				>
+			</File>
 			<File
 				RelativePath=".\xmlcdr.h"
 				>

src/mod/event_handlers/mod_cdr/sqlitecdr.cpp

@@ -190,7 +190,7 @@ void SqliteCDR::connect(switch_xml_t& cfg, switch_xml_t& xml, switch_xml_t& sett
 			
 			int sql_rc = switch_core_db_open(db_filename.c_str(),&db);
 			
-			if(sql_rc != SQLITE_OK)
+			if(sql_rc != SWITCH_CORE_DB_OK)
 			{
 				switch_console_printf(SWITCH_CHANNEL_LOG,"There was an error opening database filename %s.  The error was: %s.  SqliteCDR logging has been disabled until the problem is resolved and modcdr_reload is initiated.\n",db_filename.c_str(),switch_core_db_errmsg(db));
 				activated = 0;
@@ -211,7 +211,7 @@ void SqliteCDR::connect(switch_xml_t& cfg, switch_xml_t& xml, switch_xml_t& sett
 				temp_sql_tables["freeswitchcdr"] = 0;
 				temp_sql_tables["chanvars"] = 0;
 			
-				if(sql_rc == SQLITE_OK)
+				if(sql_rc == SWITCH_CORE_DB_OK)
 				{
 					for(int i = 0; i < ((nrow+1)*ncol); i++)
 					{
@@ -284,7 +284,7 @@ void SqliteCDR::connect(switch_xml_t& cfg, switch_xml_t& xml, switch_xml_t& sett
 					char *errormessage2;
 					sql_rc = switch_core_db_get_table(db,sql_query_get_schema_of_freeswitchcdr,&result2,&nrow,&ncol,&errormessage2);
 					
-					if(sql_rc == SQLITE_OK)
+					if(sql_rc == SWITCH_CORE_DB_OK)
 					{
 						for(int k = 0; k < nrow; k++)
 						{
@@ -451,25 +451,25 @@ bool SqliteCDR::process_record()
 	int column = 1;
 	switch_core_db_step(stmt_begin);
 	switch_core_db_reset(stmt_begin);
-	switch_core_db_bind_int64(stmt, column++, (sqlite_int64) sqlite_callstartdate);
-	switch_core_db_bind_int64(stmt, column++, (sqlite_int64) sqlite_callanswerdate);
-	switch_core_db_bind_int64(stmt, column++, (sqlite_int64) sqlite_calltransferdate);
-	switch_core_db_bind_int64(stmt, column++, (sqlite_int64) sqlite_callenddate);
+	switch_core_db_bind_int64(stmt, column++, sqlite_callstartdate);
+	switch_core_db_bind_int64(stmt, column++, sqlite_callanswerdate);
+	switch_core_db_bind_int64(stmt, column++, sqlite_calltransferdate);
+	switch_core_db_bind_int64(stmt, column++, sqlite_callenddate);
 	switch_core_db_bind_int(stmt, column++, (int) originated);
-	switch_core_db_bind_text(stmt, column++, clid,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, src,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, dst,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, ani,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, aniii,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, dialplan,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, myuuid,36,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, destuuid,36,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, srcchannel,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, dstchannel,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, network_addr,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, lastapp,-1,SQLITE_STATIC);
-	switch_core_db_bind_text(stmt, column++, lastdata,-1,SQLITE_STATIC);
-	switch_core_db_bind_int64(stmt, column++, (sqlite_int64) billusec);
+	switch_core_db_bind_text(stmt, column++, clid,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, src,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, dst,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, ani,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, aniii,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, dialplan,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, myuuid,36,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, destuuid,36,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, srcchannel,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, dstchannel,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, network_addr,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, lastapp,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_text(stmt, column++, lastdata,-1,SWITCH_CORE_DB_STATIC);
+	switch_core_db_bind_int64(stmt, column++, billusec);
 	switch_core_db_bind_int(stmt, column++, disposition);
 	switch_core_db_bind_int(stmt, column++, (int) hangupcause);
 	switch_core_db_bind_int(stmt, column++, amaflags);
@@ -510,7 +510,7 @@ bool SqliteCDR::process_record()
 				case CDR_DECIMAL:
 				case CDR_STRING:
 				{
-					switch_core_db_bind_text(stmt,column++,iItr->second.c_str(),-1,SQLITE_STATIC);
+					switch_core_db_bind_text(stmt,column++,iItr->second.c_str(),-1,SWITCH_CORE_DB_STATIC);
 					break;
 				}
 				default:
@@ -520,11 +520,11 @@ bool SqliteCDR::process_record()
 	}
 	
 	int sql_rc = switch_core_db_step(stmt);
-	if(sql_rc != SQLITE_DONE)
+	if(sql_rc != SWITCH_CORE_DB_DONE)
 	{
-		if(sql_rc == SQLITE_BUSY)
+		if(sql_rc == SWITCH_CORE_DB_BUSY)
 			sql_rc = switch_core_db_step(stmt);
-		else if (sql_rc == SQLITE_ERROR || sql_rc == SQLITE_MISUSE)
+		else if (sql_rc == SWITCH_CORE_DB_ERROR || sql_rc == SWITCH_CORE_DB_MISUSE)
 			switch_console_printf(SWITCH_CHANNEL_LOG,"There was an error executing switch_core_db_step on SqliteCDR::stmt.  The error was: %s\n",switch_core_db_errmsg(db));
 	}
 	
@@ -532,20 +532,20 @@ bool SqliteCDR::process_record()
 	
 	if(logchanvars && chanvars_supp.size())
 	{
-		sqlite_int64 rowid = switch_core_db_last_insert_rowid(db);
+		int64_t rowid = switch_core_db_last_insert_rowid(db);
 		int column2 = 1;
 		std::map<std::string,std::string>::iterator iItr, iEnd;
 		for(iItr = chanvars_supp.begin(), iEnd = chanvars_supp.end(); iItr != iEnd; iItr++)
 		{
 			switch_core_db_bind_int64(stmt_chanvars, column2++, rowid);
-			switch_core_db_bind_text(stmt_chanvars, column2++, iItr->first.c_str(),-1,SQLITE_STATIC);
-			switch_core_db_bind_text(stmt_chanvars, column2++, iItr->second.c_str(),-1,SQLITE_STATIC);
+			switch_core_db_bind_text(stmt_chanvars, column2++, iItr->first.c_str(),-1,SWITCH_CORE_DB_STATIC);
+			switch_core_db_bind_text(stmt_chanvars, column2++, iItr->second.c_str(),-1,SWITCH_CORE_DB_STATIC);
 			int sql_rc = switch_core_db_step(stmt_chanvars);
-			if(sql_rc != SQLITE_DONE)
+			if(sql_rc != SWITCH_CORE_DB_DONE)
 			{
-				if(sql_rc == SQLITE_BUSY)
+				if(sql_rc == SWITCH_CORE_DB_BUSY)
 					sql_rc = switch_core_db_step(stmt_chanvars);
-				else if (sql_rc == SQLITE_ERROR || sql_rc == SQLITE_MISUSE)
+				else if (sql_rc == SWITCH_CORE_DB_ERROR || sql_rc == SWITCH_CORE_DB_MISUSE)
 					switch_console_printf(SWITCH_CHANNEL_LOG,"There was an error executing switch_core_db_step on SqliteCDR::stmt_chanvars.  The error was: %s\n",switch_core_db_errmsg(db));
 			}
 			

src/switch_core_db.c

@@ -91,6 +91,46 @@ SWITCH_DECLARE(int) switch_core_db_step(switch_core_db_stmt_t *stmt)
 	return sqlite3_step(stmt);
 }
 
+SWITCH_DECLARE(int) switch_core_db_reset(switch_core_db_stmt_t *pStmt)
+{
+	return sqlite3_reset(pStmt);
+}
+
+SWITCH_DECLARE(int) switch_core_db_bind_int(switch_core_db_stmt_t *pStmt, int i, int iValue)
+{
+	return sqlite3_bind_int(pStmt, i, iValue);
+}
+
+SWITCH_DECLARE(int) switch_core_db_bind_int64(switch_core_db_stmt_t *pStmt, int i, int64_t iValue)
+{
+	return sqlite3_bind_int64(pStmt, i, iValue);
+}
+
+SWITCH_DECLARE(int) switch_core_db_bind_text(switch_core_db_stmt_t *pStmt, int i, const char *zData, int nData, switch_core_db_destructor_type_t xDel)
+{
+	return sqlite3_bind_text(pStmt, i, zData, nData, xDel);
+}
+
+SWITCH_DECLARE(int) switch_core_db_bind_double(switch_core_db_stmt_t *pStmt, int i, double dValue)
+{
+	return sqlite3_bind_double(pStmt, i, dValue);
+}
+
+SWITCH_DECLARE(int64_t) switch_core_db_last_insert_rowid(switch_core_db_t *db)
+{
+	return sqlite3_last_insert_rowid(db);
+}
+
+SWITCH_DECLARE(int) switch_core_db_get_table(switch_core_db_t *db, const char *sql, char ***resultp, int *nrow, int *ncolumn, char **errmsg)
+{
+	return sqlite3_get_table(db, sql, resultp, nrow, ncolumn, errmsg);
+}
+
+SWITCH_DECLARE(void) switch_core_db_free_table(char **result)
+{
+	sqlite3_free_table(result);
+}
+
 SWITCH_DECLARE(void) switch_core_db_free(char *z)
 {
 	sqlite3_free(z);