switch_pgsql.c File Reference

#include <switch.h>
#include <switch_private.h>

Include dependency graph for switch_pgsql.c:

Go to the source code of this file.

Functions
switch_pgsql_handle_t *	switch_pgsql_handle_new (const char *dsn)
	Create a new handle for the PGSQL connection. More...
void	switch_pgsql_set_num_retries (switch_pgsql_handle_t *handle, int num_retries)
	Sets the number of retries if the PGSQL connection fails. More...
switch_pgsql_status_t	switch_pgsql_handle_disconnect (switch_pgsql_handle_t *handle)
	Disconnects a PGSQL connection from the database. More...
switch_pgsql_status_t	switch_pgsql_send_query (switch_pgsql_handle_t *handle, const char *sql)
switch_pgsql_status_t	switch_pgsql_cancel_real (const char *file, const char *func, int line, switch_pgsql_handle_t *handle)
switch_pgsql_status_t	switch_pgsql_next_result_timed (switch_pgsql_handle_t *handle, switch_pgsql_result_t **result_out, int msec)
void	switch_pgsql_free_result (switch_pgsql_result_t **result)
switch_pgsql_status_t	switch_pgsql_finish_results_real (const char *file, const char *func, int line, switch_pgsql_handle_t *handle)
switch_pgsql_status_t	switch_pgsql_handle_connect (switch_pgsql_handle_t *handle)
	Connect to the database specified by the DSN passed to the switch_pgsql_handle_new() call which initialized this handle. More...
switch_pgsql_status_t	switch_pgsql_handle_exec_string_detailed (const char *file, const char *func, int line, switch_pgsql_handle_t *handle, const char *sql, char *resbuf, size_t len, char **err)
switch_pgsql_status_t	switch_pgsql_handle_exec_base_detailed (const char *file, const char *func, int line, switch_pgsql_handle_t *handle, const char *sql, char **err)
switch_pgsql_status_t	switch_pgsql_handle_exec_detailed (const char *file, const char *func, int line, switch_pgsql_handle_t *handle, const char *sql, char **err)
switch_pgsql_status_t	switch_pgsql_handle_callback_exec_detailed (const char *file, const char *func, int line, switch_pgsql_handle_t *handle, const char *sql, switch_core_db_callback_func_t callback, void *pdata, char **err)
	Execute the sql query and issue a callback for each row returned. More...
void	switch_pgsql_handle_destroy (switch_pgsql_handle_t **handlep)
switch_pgsql_state_t	switch_pgsql_handle_get_state (switch_pgsql_handle_t *handle)
char *	switch_pgsql_handle_get_error (switch_pgsql_handle_t *handle)
int	switch_pgsql_handle_affected_rows (switch_pgsql_handle_t *handle)
switch_bool_t	switch_pgsql_available (void)
switch_pgsql_status_t	switch_pgsql_SQLSetAutoCommitAttr (switch_pgsql_handle_t *handle, switch_bool_t on)
switch_pgsql_status_t	switch_pgsql_flush (switch_pgsql_handle_t *handle)
switch_pgsql_status_t	switch_pgsql_SQLEndTran (switch_pgsql_handle_t *handle, switch_bool_t commit)

Function Documentation

switch_bool_t switch_pgsql_available

(

void

)

Definition at line 819 of file switch_pgsql.c.

References SWITCH_FALSE, and SWITCH_TRUE.

Referenced by _switch_cache_db_get_db_handle(), and switch_load_core_config().

{
#ifdef SWITCH_HAVE_PGSQL
        return SWITCH_TRUE;
#else
        return SWITCH_FALSE;
#endif
}

switch_pgsql_status_t switch_pgsql_cancel_real	(	const char *	file,
		const char *	func,
		int	line,
		switch_pgsql_handle_t *	handle
	)

Definition at line 266 of file switch_pgsql.c.

References memset(), SWITCH_CHANNEL_ID_LOG, SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_PGSQL_FAIL, switch_pgsql_flush(), and SWITCH_PGSQL_SUCCESS.

{
        switch_pgsql_status_t ret = SWITCH_PGSQL_SUCCESS;
#ifdef SWITCH_HAVE_PGSQL
        char err_buf[256];
        PGcancel *cancel = NULL;

        memset(err_buf, 0, 256);
        cancel = PQgetCancel(handle->con);
        if(!PQcancel(cancel, err_buf, 256)) {
                switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_CRIT, "Failed to cancel long-running query (%s): %s\n", handle->sql, err_buf);
                ret = SWITCH_PGSQL_FAIL;
        }
        PQfreeCancel(cancel);
        switch_pgsql_flush(handle);

#endif
        return ret;
}

switch_pgsql_status_t switch_pgsql_finish_results_real	(	const char *	file,
		const char *	func,
		int	line,
		switch_pgsql_handle_t *	handle
	)

Definition at line 457 of file switch_pgsql.c.

References SWITCH_CHANNEL_ID_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PGSQL_FAIL, switch_pgsql_free_result(), switch_pgsql_next_result, SWITCH_PGSQL_SUCCESS, switch_stristr(), and zstr.

{
#ifdef SWITCH_HAVE_PGSQL
        switch_pgsql_result_t *res = NULL;
        switch_pgsql_status_t final_status = SWITCH_PGSQL_SUCCESS;
        int done = 0;
        do {
                switch_pgsql_next_result(handle, &res);
                if (res && res->err && !switch_stristr("already exists", res->err) && !switch_stristr("duplicate key name", res->err)) {
                        switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "Error executing query:\n%s\n", res->err);
                        final_status = SWITCH_PGSQL_FAIL;
                }

                if (!res) {
                        done = 1;
                } else if (res->result) {
                        char *affected_rows = PQcmdTuples(res->result);

                        if (!zstr(affected_rows)) {
                                handle->affected_rows = atoi(affected_rows);
                        }
                }

                switch_pgsql_free_result(&res);
        } while (!done);
        return final_status;
#else
        return SWITCH_PGSQL_FAIL;
#endif
}

switch_pgsql_status_t switch_pgsql_flush

(

switch_pgsql_handle_t *

handle

)

Definition at line 842 of file switch_pgsql.c.

References SWITCH_CHANNEL_LOG, SWITCH_FALSE, SWITCH_LOG_DEBUG10, switch_log_printf(), and SWITCH_PGSQL_SUCCESS.

Referenced by switch_cache_db_release_db_handle(), switch_pgsql_cancel_real(), switch_pgsql_handle_exec_base_detailed(), and switch_pgsql_next_result_timed().

{
#ifdef SWITCH_HAVE_PGSQL

        PGresult *tmp = NULL;
        int x = 0;

        /* Make sure the query is fully cleared */
        while ((tmp = PQgetResult(handle->con)) != NULL) {
                PQclear(tmp);
                x++;
        }
        
        if (x) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Flushing %d results\n", x);
        }

        return SWITCH_PGSQL_SUCCESS;
#else
        return (switch_pgsql_status_t) SWITCH_FALSE;
#endif
}

void switch_pgsql_free_result

(

switch_pgsql_result_t **

result

)

Definition at line 439 of file switch_pgsql.c.

Referenced by switch_pgsql_finish_results_real(), switch_pgsql_handle_callback_exec_detailed(), and switch_pgsql_handle_exec_string_detailed().

{
#ifdef SWITCH_HAVE_PGSQL

        if (!*result) {
                return;
        }

        if ((*result)->result) {
                PQclear((*result)->result);
        }
        free(*result);
        *result = NULL;
#else
        return;
#endif
}

int switch_pgsql_handle_affected_rows

(

switch_pgsql_handle_t *

handle

)

Definition at line 810 of file switch_pgsql.c.

Referenced by switch_cache_db_affected_rows().

{
#ifdef SWITCH_HAVE_PGSQL
        return handle->affected_rows;
#else
        return 0;
#endif
}

switch_pgsql_status_t switch_pgsql_handle_callback_exec_detailed	(	const char *	file,
		const char *	func,
		int	line,
		switch_pgsql_handle_t *	handle,
		const char *	sql,
		switch_core_db_callback_func_t	callback,
		void *	pdata,
		char **	err
	)

Execute the sql query and issue a callback for each row returned.

Parameters

file	the file from which this function is called
func	the function from which this function is called
line	the line from which this function is called
handle	the PGSQL handle
sql	the sql string to execute
callback	the callback function to execute
pdata	the state data passed on each callback invocation

Returns

SWITCH_STATUS_SUCCESS if the operation was successful

Note

none

Definition at line 662 of file switch_pgsql.c.

References switch_assert, SWITCH_CHANNEL_ID_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PGSQL_FAIL, switch_pgsql_finish_results, switch_pgsql_free_result(), switch_pgsql_handle_exec_base, switch_pgsql_handle_get_error(), switch_pgsql_next_result, SWITCH_PGSQL_SUCCESS, switch_safe_free, switch_str_nil, and zstr.

{
#ifdef SWITCH_HAVE_PGSQL
        char *err_str = NULL;
        int row = 0, col = 0, err_cnt = 0;
        switch_pgsql_result_t *result = NULL;

        handle->affected_rows = 0;

        switch_assert(callback != NULL);

        if (switch_pgsql_handle_exec_base(handle, sql, err) == SWITCH_PGSQL_FAIL) {
                goto error;
        }
        
        if (switch_pgsql_next_result(handle, &result) == SWITCH_PGSQL_FAIL) {
                err_cnt++;
                err_str = switch_pgsql_handle_get_error(handle);
                if (result && !zstr(result->err)) {
                        switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(result->err));
                }
                if (!zstr(err_str)) {
                        switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(err_str));
                }
                switch_safe_free(err_str);
                err_str = NULL;
        }

        while (result != NULL) {
                /*switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Processing result with %d rows and %d columns.\n", result->rows, result->cols);*/
                for (row = 0; row < result->rows; ++row) {
                        char **names;
                        char **vals;

                        names = calloc(result->cols, sizeof(*names));
                        vals = calloc(result->cols, sizeof(*vals));

                        switch_assert(names && vals);

                        for (col = 0; col < result->cols; ++col) {
                                char * tmp;
                                int len;

                                tmp = PQfname(result->result, col);
                                if (tmp) {
                                        len = strlen(tmp);
                                        names[col] = malloc(len+1);
                                        names[col][len] = '\0';
                                        strncpy(names[col], tmp, len);
                                        
                                        len = PQgetlength(result->result, row, col);
                                        vals[col] = malloc(len+1);
                                        vals[col][len] = '\0';
                                        tmp = PQgetvalue(result->result, row, col);
                                        strncpy(vals[col], tmp, len);
                                        /*switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Processing result row %d, col %d: %s => %s\n", row, col, names[col], vals[col]);*/
                                } else {
                                        /*switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Processing result row %d, col %d.\n", row, col);*/
                                        switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: Column number %d out of range\n", col);
                                }
                        }

                        /*switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "Executing callback for row %d...\n", row);*/
                        if (callback(pdata, result->cols, vals, names)) {
                                switch_pgsql_finish_results(handle); /* Makes sure next call to switch_pgsql_next_result will return NULL */
                                row = result->rows;                  /* Makes us exit the for loop */
                        }

                        for (col = 0; col < result->cols; ++col) {
                                free(names[col]);
                                free(vals[col]);
                        }
                        free(names);
                        free(vals);
                }
                switch_pgsql_free_result(&result);
                if (switch_pgsql_next_result(handle, &result) == SWITCH_PGSQL_FAIL) {
                        err_cnt++;
                        err_str = switch_pgsql_handle_get_error(handle);
                        if (result && !zstr(result->err)) {
                                switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(result->err));
                        }
                        if (!zstr(err_str)) {
                                switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(err_str));
                        }
                        switch_safe_free(err_str);
                        err_str = NULL;
                }
        }
        if (err_cnt) {
                goto error;
        }

        return SWITCH_PGSQL_SUCCESS;
 error:
#endif
        return SWITCH_PGSQL_FAIL;
}

switch_pgsql_status_t switch_pgsql_handle_connect

(

switch_pgsql_handle_t *

handle

)

Connect to the database specified by the DSN passed to the switch_pgsql_handle_new() call which initialized this handle.

Parameters

The	database handle to connect to the database.

Returns

Returns SWITCH_PGSQL_SUCCESS or SWITCH_PGSQL_FAIL.

Definition at line 489 of file switch_pgsql.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PGSQL_FAIL, switch_pgsql_handle_disconnect(), switch_pgsql_handle_get_error(), SWITCH_PGSQL_STATE_CONNECTED, SWITCH_PGSQL_SUCCESS, and switch_safe_free.

Referenced by _switch_cache_db_get_db_handle().

{
#ifdef SWITCH_HAVE_PGSQL
        if (handle->state == SWITCH_PGSQL_STATE_CONNECTED) {
                switch_pgsql_handle_disconnect(handle);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Re-connecting %s\n", handle->dsn);
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Connecting %s\n", handle->dsn);

        handle->con = PQconnectdb(handle->dsn);
        if (PQstatus(handle->con) != CONNECTION_OK) {
                char *err_str;
                if ((err_str = switch_pgsql_handle_get_error(handle))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s\n", err_str);
                        switch_safe_free(err_str);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to connect to the database [%s]\n", handle->dsn);
                        switch_pgsql_handle_disconnect(handle);
                }
                return SWITCH_PGSQL_FAIL;
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Connected to [%s]\n", handle->dsn);
        handle->state = SWITCH_PGSQL_STATE_CONNECTED;
        handle->sock = PQsocket(handle->con);
        return SWITCH_PGSQL_SUCCESS;
#else
        return SWITCH_PGSQL_FAIL;
#endif
}

void switch_pgsql_handle_destroy

(

switch_pgsql_handle_t **

handlep

)

Definition at line 764 of file switch_pgsql.c.

References switch_pgsql_handle_disconnect(), and switch_safe_free.

Referenced by _switch_cache_db_get_db_handle(), and sql_close().

{
#ifdef SWITCH_HAVE_PGSQL

        switch_pgsql_handle_t *handle = NULL;

        if (!handlep) {
                return;
        }
        handle = *handlep;

        if (handle) {
                switch_pgsql_handle_disconnect(handle);

                switch_safe_free(handle->dsn);
                free(handle);
        }
        *handlep = NULL;
#else
        return;
#endif
}

switch_pgsql_status_t switch_pgsql_handle_disconnect

(

switch_pgsql_handle_t *

handle

)

Disconnects a PGSQL connection from the database.

Parameters

handle

The PGSQL database handle to disconnect.

Returns

Returns SWITCH_PGSQL_SUCCESS or SWITCH_PGSQL_FAIL.

Definition at line 225 of file switch_pgsql.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, switch_log_printf(), SWITCH_PGSQL_FAIL, SWITCH_PGSQL_STATE_CONNECTED, SWITCH_PGSQL_STATE_DOWN, SWITCH_PGSQL_SUCCESS, and switch_safe_free.

Referenced by switch_pgsql_handle_connect(), and switch_pgsql_handle_destroy().

{
#ifdef SWITCH_HAVE_PGSQL

        if (!handle) {
                return SWITCH_PGSQL_FAIL;
        }

        if (handle->state == SWITCH_PGSQL_STATE_CONNECTED) {
                PQfinish(handle->con);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Disconnected from [%s]\n", handle->dsn);
        }
        switch_safe_free(handle->sql);
        handle->state = SWITCH_PGSQL_STATE_DOWN;

        return SWITCH_PGSQL_SUCCESS;
#else
        return SWITCH_PGSQL_FAIL;
#endif
}

switch_pgsql_status_t switch_pgsql_handle_exec_base_detailed	(	const char *	file,
		const char *	func,
		int	line,
		switch_pgsql_handle_t *	handle,
		const char *	sql,
		char **	err
	)

Definition at line 576 of file switch_pgsql.c.

References SWITCH_CHANNEL_ID_LOG, SWITCH_FALSE, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PGSQL_FAIL, switch_pgsql_finish_results, switch_pgsql_flush(), switch_pgsql_handle_get_error(), switch_pgsql_send_query(), SWITCH_PGSQL_SUCCESS, switch_str_nil, switch_stristr(), SWITCH_TRUE, and zstr.

Referenced by switch_pgsql_handle_exec_detailed(), and switch_pgsql_handle_exec_string_detailed().

{
#ifdef SWITCH_HAVE_PGSQL
        char *err_str = NULL, *er = NULL;



        switch_pgsql_flush(handle);
        handle->affected_rows = 0;

        if (!db_is_up(handle)) {
                er = strdup("Database is not up!");
                goto error;
        }

        if (handle->auto_commit == SWITCH_FALSE && handle->in_txn == SWITCH_FALSE) {
                if (switch_pgsql_send_query(handle, "BEGIN") != SWITCH_PGSQL_SUCCESS) {
                        er = strdup("Error sending BEGIN!");
                        if (switch_pgsql_finish_results(handle) != SWITCH_PGSQL_SUCCESS) {
                                db_is_up(handle); /* If finish_results failed, maybe the db went dead */
                        }
                        goto error;
                }

                if (switch_pgsql_finish_results(handle) != SWITCH_PGSQL_SUCCESS) {
                        db_is_up(handle);
                        er = strdup("Error sending BEGIN!");
                        goto error;
                }
                handle->in_txn = SWITCH_TRUE;
        }

        if (switch_pgsql_send_query(handle, sql) != SWITCH_PGSQL_SUCCESS) {
                er = strdup("Error sending query!");
                if (switch_pgsql_finish_results(handle) != SWITCH_PGSQL_SUCCESS) {
                        db_is_up(handle);
                }
                goto error;
        }

        return SWITCH_PGSQL_SUCCESS;

  error:
        err_str = switch_pgsql_handle_get_error(handle);

        if (zstr(err_str)) {
                if (zstr(er)) {
                        err_str = strdup((char *)"SQL ERROR!");
                } else {
                        err_str = er;
                }
        } else {
                if (!zstr(er)) {
                        free(er);
                }
        }
        
        if (err_str) {
                if (!switch_stristr("already exists", err_str) && !switch_stristr("duplicate key name", err_str)) {
                        switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(err_str));
                }
                if (err) {
                        *err = err_str;
                } else {
                        free(err_str);
                }
        }
#endif
        return SWITCH_PGSQL_FAIL;
}

switch_pgsql_status_t switch_pgsql_handle_exec_detailed	(	const char *	file,
		const char *	func,
		int	line,
		switch_pgsql_handle_t *	handle,
		const char *	sql,
		char **	err
	)

Definition at line 648 of file switch_pgsql.c.

References SWITCH_PGSQL_FAIL, switch_pgsql_finish_results, and switch_pgsql_handle_exec_base_detailed().

{
#ifdef SWITCH_HAVE_PGSQL
        if (switch_pgsql_handle_exec_base_detailed(file, func, line, handle, sql, err) == SWITCH_PGSQL_FAIL) {
                goto error;
        }

        return switch_pgsql_finish_results(handle);
  error:
#endif
        return SWITCH_PGSQL_FAIL;
}

switch_pgsql_status_t switch_pgsql_handle_exec_string_detailed	(	const char *	file,
		const char *	func,
		int	line,
		switch_pgsql_handle_t *	handle,
		const char *	sql,
		char *	resbuf,
		size_t	len,
		char **	err
	)

Definition at line 521 of file switch_pgsql.c.

References SWITCH_PGSQL_FAIL, switch_pgsql_finish_results, switch_pgsql_free_result(), switch_pgsql_handle_exec_base_detailed(), switch_pgsql_next_result, and SWITCH_PGSQL_SUCCESS.

{
#ifdef SWITCH_HAVE_PGSQL
        switch_pgsql_status_t sstatus = SWITCH_PGSQL_SUCCESS;
        char *val = NULL;
        switch_pgsql_result_t *result = NULL;

        handle->affected_rows = 0;

        if (switch_pgsql_handle_exec_base_detailed(file, func, line, handle, sql, err) == SWITCH_PGSQL_FAIL) {
                goto error;
        }

        if(switch_pgsql_next_result(handle, &result) == SWITCH_PGSQL_FAIL) {
                goto error;
        }

        if (result) {
                switch (result->status) {
#if POSTGRESQL_MAJOR_VERSION >= 9 && POSTGRESQL_MINOR_VERSION >= 2
                case PGRES_SINGLE_TUPLE:
                        /* Added in PostgreSQL 9.2 */
#endif
                case PGRES_COMMAND_OK:
                case PGRES_TUPLES_OK:
                        break;
                default:
                        sstatus = SWITCH_PGSQL_FAIL;
                        goto done;
                }
        }

        if (handle->affected_rows <= 0) {
                goto done;
        }

        val = PQgetvalue(result->result, 0, 0);
        strncpy(resbuf, val, len);

        done:

        switch_pgsql_free_result(&result);
        if (switch_pgsql_finish_results(handle) != SWITCH_PGSQL_SUCCESS) {
                sstatus = SWITCH_PGSQL_FAIL;
        }

        return sstatus;
 error:
        return SWITCH_PGSQL_FAIL;
#else
        return SWITCH_PGSQL_FAIL;
#endif
}

char* switch_pgsql_handle_get_error

(

switch_pgsql_handle_t *

handle

)

Definition at line 796 of file switch_pgsql.c.

References switch_strdup.

Referenced by switch_pgsql_handle_callback_exec_detailed(), switch_pgsql_handle_connect(), switch_pgsql_handle_exec_base_detailed(), switch_pgsql_next_result_timed(), switch_pgsql_send_query(), and switch_pgsql_SQLEndTran().

{
#ifdef SWITCH_HAVE_PGSQL
        char * err_str;
        if (!handle) {
                return NULL;
        };
        switch_strdup(err_str, PQerrorMessage(handle->con));
        return err_str;
#else
        return NULL;
#endif
}

switch_pgsql_state_t switch_pgsql_handle_get_state

(

switch_pgsql_handle_t *

handle

)

Definition at line 787 of file switch_pgsql.c.

References SWITCH_PGSQL_STATE_ERROR, and SWITCH_PGSQL_STATE_INIT.

{
#ifdef SWITCH_HAVE_PGSQL
        return handle ? handle->state : SWITCH_PGSQL_STATE_INIT;
#else
        return SWITCH_PGSQL_STATE_ERROR;
#endif
}

switch_pgsql_handle_t* switch_pgsql_handle_new

(

const char *

dsn

)

Create a new handle for the PGSQL connection.

Parameters

dsn

The DSN of the database to connect to. See documentation for PQconnectdb() at http://www.postgresql.org/docs/9.0/static/libpq-connect.html. The DSN MUST be prefixed with 'pgsql;' to use the switch_cache_db* functionality. However, the DSN passed to this function directly MUST NOT be prefixed with 'pgsql;'.

Returns

Returns a pointer to a newly allocated switch_pgsql_handle_t type or NULL on failure.

Definition at line 66 of file switch_pgsql.c.

References DEFAULT_PGSQL_RETRIES, memset(), SWITCH_FALSE, SWITCH_PGSQL_STATE_INIT, switch_safe_free, and SWITCH_TRUE.

Referenced by _switch_cache_db_get_db_handle().

{
#ifdef SWITCH_HAVE_PGSQL
        switch_pgsql_handle_t *new_handle;

        if (!(new_handle = malloc(sizeof(*new_handle)))) {
                goto err;
        }

        memset(new_handle, 0, sizeof(*new_handle));

        if (!(new_handle->dsn = strdup(dsn))) {
                goto err;
        }

        new_handle->sock = 0;
        new_handle->state = SWITCH_PGSQL_STATE_INIT;
        new_handle->con = NULL;
        new_handle->affected_rows = 0;
        new_handle->num_retries = DEFAULT_PGSQL_RETRIES;
        new_handle->auto_commit = SWITCH_TRUE;
        new_handle->in_txn = SWITCH_FALSE;

        return new_handle;

  err:
        if (new_handle) {
                switch_safe_free(new_handle->dsn);
                switch_safe_free(new_handle);
        }
#endif
        return NULL;
}

switch_pgsql_status_t switch_pgsql_next_result_timed	(	switch_pgsql_handle_t *	handle,
		switch_pgsql_result_t **	result_out,
		int	msec
	)

Definition at line 287 of file switch_pgsql.c.

References memset(), SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, switch_log_printf(), switch_micro_time_now(), switch_pgsql_cancel, SWITCH_PGSQL_FAIL, switch_pgsql_flush(), switch_pgsql_handle_get_error(), SWITCH_PGSQL_STATE_ERROR, SWITCH_PGSQL_SUCCESS, and switch_safe_free.

{
#ifdef SWITCH_HAVE_PGSQL
        switch_pgsql_result_t *res;
        switch_time_t start;
        switch_time_t ctime;
        unsigned int usec = msec * 1000;
        char *err_str;
        struct pollfd fds[2] = { {0} };
        int poll_res = 0;
        
        if(!handle) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "**BUG** Null handle passed to switch_pgsql_next_result.\n");
                return SWITCH_PGSQL_FAIL;
        }

        /* Try to consume input that might be waiting right away */
        if (PQconsumeInput(handle->con)) {
                /* And check to see if we have a full result ready for reading */
                if (PQisBusy(handle->con)) {

                        /* Wait for a result to become available, up to msec milliseconds */
                        start = switch_micro_time_now();
                        while((ctime = switch_micro_time_now()) - start <= usec) {
                                int wait_time = (usec - (ctime - start)) / 1000;
                                fds[0].fd = handle->sock;
                                fds[0].events |= POLLIN;
                                fds[0].events |= POLLERR;
                                fds[0].events |= POLLNVAL;
                                fds[0].events |= POLLHUP;
                                fds[0].events |= POLLPRI;
                                fds[0].events |= POLLRDNORM;
                                fds[0].events |= POLLRDBAND;

                                /* Wait for the PostgreSQL socket to be ready for data reads. */
                                if ((poll_res = poll(&fds[0], 1, wait_time)) > 0 ) {
                                        if (fds[0].revents & POLLHUP || fds[0].revents & POLLNVAL) {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "PGSQL socket closed or invalid while waiting for result for query (%s)\n", handle->sql);
                                                goto error;
                                        } else if (fds[0].revents & POLLERR) {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Poll error trying to read PGSQL socket for query (%s)\n", handle->sql);
                                                goto error;
                                        } else if (fds[0].revents & POLLIN || fds[0].revents & POLLPRI || fds[0].revents & POLLRDNORM || fds[0].revents & POLLRDBAND) {
                                                /* Then try to consume any input waiting. */
                                                if (PQconsumeInput(handle->con)) {
                                                        if (PQstatus(handle->con) == CONNECTION_BAD) {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Connection terminated while waiting for result.\n");
                                                                handle->state = SWITCH_PGSQL_STATE_ERROR;
                                                                goto error;
                                                        }

                                                        /* And check to see if we have a full result ready for reading */
                                                        if (!PQisBusy(handle->con)) {
                                                                /* If we can pull a full result without blocking, then break this loop */
                                                                break;
                                                        }
                                                } else {
                                                        /* If we had an error trying to consume input, report it and cancel the query. */
                                                        err_str = switch_pgsql_handle_get_error(handle);
                                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "An error occurred trying to consume input for query (%s): %s\n", handle->sql, err_str);
                                                        switch_safe_free(err_str);
                                                        switch_pgsql_cancel(handle);
                                                        goto error;
                                                }
                                        }
                                } else if (poll_res == -1) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Poll failed trying to read PGSQL socket for query (%s)\n", handle->sql);
                                        goto error;
                                }
                        }

                        /* If we broke the loop above because of a timeout, report that and cancel the query. */
                        if (ctime - start > usec) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Query (%s) took too long to complete or database not responding.\n", handle->sql);
                                switch_pgsql_cancel(handle);
                                goto error;
                        }

                }
        } else {
                /* If we had an error trying to consume input, report it and cancel the query. */
                err_str = switch_pgsql_handle_get_error(handle);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "An error occurred trying to consume input for query (%s): %s\n", handle->sql, err_str);
                switch_safe_free(err_str);
                /* switch_pgsql_cancel(handle); */
                goto error;
        }


        /* At this point, we know we can read a full result without blocking. */
        if(!(res = malloc(sizeof(switch_pgsql_result_t)))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Malloc failed!\n");
                goto error;
        }
        memset(res, 0, sizeof(switch_pgsql_result_t));

        
        res->result = PQgetResult(handle->con);
        if (res->result) {
                *result_out = res;
                res->status = PQresultStatus(res->result);
                switch(res->status) {
#if POSTGRESQL_MAJOR_VERSION >= 9 && POSTGRESQL_MINOR_VERSION >= 2
                case PGRES_SINGLE_TUPLE:
                        /* Added in PostgreSQL 9.2 */
#endif
                case PGRES_TUPLES_OK:
                        {
                                res->rows = PQntuples(res->result);
                                handle->affected_rows = res->rows;
                                res->cols = PQnfields(res->result);
                        }
                        break;
#if POSTGRESQL_MAJOR_VERSION >= 9 && POSTGRESQL_MINOR_VERSION >= 1
                case PGRES_COPY_BOTH:
                        /* Added in PostgreSQL 9.1 */
#endif
                case PGRES_COPY_OUT:
                case PGRES_COPY_IN:
                case PGRES_COMMAND_OK:
                        break;
                case PGRES_EMPTY_QUERY:
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Query (%s) returned PGRES_EMPTY_QUERY\n", handle->sql);
                case PGRES_BAD_RESPONSE:
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Query (%s) returned PGRES_BAD_RESPONSE\n", handle->sql);
                case PGRES_NONFATAL_ERROR:
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Query (%s) returned PGRES_NONFATAL_ERROR\n", handle->sql);
                case PGRES_FATAL_ERROR:
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Query (%s) returned PGRES_FATAL_ERROR\n", handle->sql);
                        res->err = PQresultErrorMessage(res->result);
                        goto error;
                        break;
                }
        } else {
                free(res);
                res = NULL;
                *result_out = NULL;
        }

        return SWITCH_PGSQL_SUCCESS;
 error:

        /* Make sure the failed connection does not have any transactions marked as in progress */
        switch_pgsql_flush(handle);

        /* Try to reconnect to the DB if we were dropped */
        db_is_up(handle);

#endif
        return SWITCH_PGSQL_FAIL;
}

switch_pgsql_status_t switch_pgsql_send_query	(	switch_pgsql_handle_t *	handle,
		const char *	sql
	)

Definition at line 246 of file switch_pgsql.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_PGSQL_FAIL, switch_pgsql_finish_results, switch_pgsql_handle_get_error(), SWITCH_PGSQL_SUCCESS, and switch_safe_free.

Referenced by switch_pgsql_handle_exec_base_detailed().

{
#ifdef SWITCH_HAVE_PGSQL
        char *err_str;

        switch_safe_free(handle->sql);
        handle->sql = strdup(sql);
        if (!PQsendQuery(handle->con, sql)) {
                err_str = switch_pgsql_handle_get_error(handle);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Failed to send query (%s) to database: %s\n", sql, err_str);
                switch_pgsql_finish_results(handle);
                goto error;
        }

        return SWITCH_PGSQL_SUCCESS;
 error:
#endif
        return SWITCH_PGSQL_FAIL;
}

void switch_pgsql_set_num_retries	(	switch_pgsql_handle_t *	handle,
		int	num_retries
	)

Sets the number of retries if the PGSQL connection fails.

Parameters

handle	A fully allocated switch_pgsql_handle_t returned from a call to switch_pgsql_handle_new().
num_retries	How many times to retry connecting to the database if this connection fails.

Definition at line 216 of file switch_pgsql.c.

{
#ifdef SWITCH_HAVE_PGSQL
        if (handle) {
                handle->num_retries = num_retries;
        }
#endif
}

switch_pgsql_status_t switch_pgsql_SQLEndTran	(	switch_pgsql_handle_t *	handle,
		switch_bool_t	commit
	)

Definition at line 865 of file switch_pgsql.c.

References SWITCH_CHANNEL_LOG, SWITCH_FALSE, SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_PGSQL_FAIL, switch_pgsql_handle_get_error(), SWITCH_PGSQL_SUCCESS, and switch_safe_free.

Referenced by do_trans(), switch_cache_db_persistant_execute_trans_full(), and switch_core_sqldb_start().

{
#ifdef SWITCH_HAVE_PGSQL
        char * err_str = NULL;
        if (commit) {
                if(!PQsendQuery(handle->con, "COMMIT")) {
                        err_str = switch_pgsql_handle_get_error(handle);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not commit transaction: %s\n", err_str);
                        switch_safe_free(err_str);
                        return SWITCH_PGSQL_FAIL;
                }
        } else {
                if(!PQsendQuery(handle->con, "ROLLBACK")) {
                        err_str = switch_pgsql_handle_get_error(handle);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not rollback transaction: %s\n", err_str);
                        switch_safe_free(err_str);
                        return SWITCH_PGSQL_FAIL;
                }
        }
        handle->in_txn = SWITCH_FALSE;
        return SWITCH_PGSQL_SUCCESS;
#else
        return (switch_pgsql_status_t) SWITCH_FALSE;
#endif
}

switch_pgsql_status_t switch_pgsql_SQLSetAutoCommitAttr	(	switch_pgsql_handle_t *	handle,
		switch_bool_t	on
	)

Definition at line 828 of file switch_pgsql.c.

References SWITCH_FALSE, SWITCH_PGSQL_SUCCESS, and SWITCH_TRUE.

Referenced by do_trans(), switch_cache_db_persistant_execute_trans_full(), and switch_core_sqldb_start().

{
#ifdef SWITCH_HAVE_PGSQL
        if (on) {
                handle->auto_commit = SWITCH_TRUE;
        } else {
                handle->auto_commit = SWITCH_FALSE;
        }
        return SWITCH_PGSQL_SUCCESS;
#else
        return (switch_pgsql_status_t) SWITCH_FALSE;
#endif
}