From d4f9417d8c5c4f533e1206554520d7a519ecd4d9 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Tue, 4 Apr 2023 17:26:51 +0200 Subject: [PATCH] -spelling, typos, indentation --- src/exchangedb/spi/own_test.c | 493 ++++++++++++++++-------------- src/exchangedb/spi/pg_aggregate.c | 278 +++++++++-------- 2 files changed, 420 insertions(+), 351 deletions(-) diff --git a/src/exchangedb/spi/own_test.c b/src/exchangedb/spi/own_test.c index 10af02e31..7da89cbd2 100644 --- a/src/exchangedb/spi/own_test.c +++ b/src/exchangedb/spi/own_test.c @@ -19,145 +19,154 @@ PG_MODULE_MAGIC; #endif -typedef struct { +typedef struct +{ Datum col1; Datum col2; } valuest; -void _PG_init(void); -void _PG_fini(void); +void _PG_init (void); -void _PG_init(void) +void _PG_fini (void); + +void +_PG_init (void) { } -PG_FUNCTION_INFO_V1(pg_spi_insert_int); -PG_FUNCTION_INFO_V1(pg_spi_select_from_x); -PG_FUNCTION_INFO_V1(pg_spi_select_pair_from_y); -//PG_FUNCTION_INFO_V1(pg_spi_select_with_cond); -PG_FUNCTION_INFO_V1(pg_spi_update_y); -PG_FUNCTION_INFO_V1(pg_spi_prepare_example); -PG_FUNCTION_INFO_V1(pg_spi_prepare_example_without_saveplan); -PG_FUNCTION_INFO_V1(pg_spi_prepare_insert); -PG_FUNCTION_INFO_V1(pg_spi_prepare_insert_without_saveplan); -//PG_FUNCTION_INFO_V1(pg_spi_prepare_select_with_cond); -PG_FUNCTION_INFO_V1(pg_spi_prepare_select_with_cond_without_saveplan); -PG_FUNCTION_INFO_V1(pg_spi_prepare_update); -PG_FUNCTION_INFO_V1(pg_spi_get_dep_ref_fees); + +PG_FUNCTION_INFO_V1 (pg_spi_insert_int); +PG_FUNCTION_INFO_V1 (pg_spi_select_from_x); +PG_FUNCTION_INFO_V1 (pg_spi_select_pair_from_y); +// PG_FUNCTION_INFO_V1(pg_spi_select_with_cond); +PG_FUNCTION_INFO_V1 (pg_spi_update_y); +PG_FUNCTION_INFO_V1 (pg_spi_prepare_example); +PG_FUNCTION_INFO_V1 (pg_spi_prepare_example_without_saveplan); +PG_FUNCTION_INFO_V1 (pg_spi_prepare_insert); +PG_FUNCTION_INFO_V1 (pg_spi_prepare_insert_without_saveplan); +// PG_FUNCTION_INFO_V1(pg_spi_prepare_select_with_cond); +PG_FUNCTION_INFO_V1 (pg_spi_prepare_select_with_cond_without_saveplan); +PG_FUNCTION_INFO_V1 (pg_spi_prepare_update); +PG_FUNCTION_INFO_V1 (pg_spi_get_dep_ref_fees); // SIMPLE SELECT Datum -pg_spi_prepare_example(PG_FUNCTION_ARGS) +pg_spi_prepare_example (PG_FUNCTION_ARGS) { static SPIPlanPtr prepared_plan; int ret; int64 result; - char * value; + char *value; SPIPlanPtr new_plan; - ret=SPI_connect(); - if (ret != SPI_OK_CONNECT) { - elog(ERROR, "DB connexion failed ! \n"); + ret = SPI_connect (); + if (ret != SPI_OK_CONNECT) + { + elog (ERROR, "DB connection failed ! \n"); } { if (prepared_plan == NULL) { - new_plan = SPI_prepare("SELECT 1 FROM joseph_test.X", 0, NULL); - prepared_plan = SPI_saveplan(new_plan); + new_plan = SPI_prepare ("SELECT 1 FROM joseph_test.X", 0, NULL); + prepared_plan = SPI_saveplan (new_plan); if (prepared_plan == NULL) { - elog(ERROR, "FAIL TO SAVE !\n"); + elog (ERROR, "FAIL TO SAVE !\n"); } } - ret = SPI_execute_plan(prepared_plan, NULL, 0,false, 0); - if (ret != SPI_OK_SELECT) { - elog(ERROR, "SELECT FAILED %d !\n", ret); + ret = SPI_execute_plan (prepared_plan, NULL, 0,false, 0); + if (ret != SPI_OK_SELECT) + { + elog (ERROR, "SELECT FAILED %d !\n", ret); } - if (SPI_tuptable != NULL && SPI_tuptable->vals != NULL && SPI_tuptable->tupdesc != NULL) + if (SPI_tuptable != NULL && SPI_tuptable->vals != NULL && + SPI_tuptable->tupdesc != NULL) { - value = SPI_getvalue(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1); - result = atoi(value); + value = SPI_getvalue (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1); + result = atoi (value); } else { - elog(ERROR, "EMPTY TABLE !\n"); + elog (ERROR, "EMPTY TABLE !\n"); } } - SPI_finish(); - PG_RETURN_INT64(result); + SPI_finish (); + PG_RETURN_INT64 (result); } - Datum -pg_spi_prepare_example_without_saveplan(PG_FUNCTION_ARGS) +pg_spi_prepare_example_without_saveplan (PG_FUNCTION_ARGS) { int ret; int64 result; - char * value; + char *value; SPIPlanPtr new_plan; - ret=SPI_connect(); - if (ret != SPI_OK_CONNECT) { - elog(ERROR, "DB connexion failed ! \n"); + ret = SPI_connect (); + if (ret != SPI_OK_CONNECT) + { + elog (ERROR, "DB connection failed ! \n"); } { - new_plan = SPI_prepare("SELECT 1 FROM joseph_test.X", 0, NULL); - ret = SPI_execute_plan(new_plan, NULL, 0,false, 0); - if (ret != SPI_OK_SELECT) { - elog(ERROR, "SELECT FAILED %d !\n", ret); + new_plan = SPI_prepare ("SELECT 1 FROM joseph_test.X", 0, NULL); + ret = SPI_execute_plan (new_plan, NULL, 0,false, 0); + if (ret != SPI_OK_SELECT) + { + elog (ERROR, "SELECT FAILED %d !\n", ret); } if (SPI_tuptable != NULL && SPI_tuptable->vals != NULL && SPI_tuptable->tupdesc != NULL) { - value = SPI_getvalue(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1); - result = atoi(value); + value = SPI_getvalue (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1); + result = atoi (value); } else { - elog(ERROR, "EMPTY TABLE !\n"); + elog (ERROR, "EMPTY TABLE !\n"); } } - SPI_finish(); - PG_RETURN_INT64(result);// PG_RETURN_INT64(result); + SPI_finish (); + PG_RETURN_INT64 (result);// PG_RETURN_INT64(result); } -//SELECT 1 FROM X -//V1 +// SELECT 1 FROM X +// V1 Datum -pg_spi_select_from_x(PG_FUNCTION_ARGS) +pg_spi_select_from_x (PG_FUNCTION_ARGS) { int ret; char *query = "SELECT 1 FROM joseph_test.X"; uint64 proc; - ret = SPI_connect(); + ret = SPI_connect (); if (ret != SPI_OK_CONNECT) { - elog(ERROR, "SPI_connect failed"); + elog (ERROR, "SPI_connect failed"); } - ret = SPI_exec(query, 10); + ret = SPI_exec (query, 10); proc = SPI_processed; if (ret != SPI_OK_SELECT) { - elog(ERROR, "SPI_exec failed"); + elog (ERROR, "SPI_exec failed"); } - SPI_finish(); + SPI_finish (); - PG_RETURN_INT64(proc); + PG_RETURN_INT64 (proc); } -//INSERT INTO X VALUES (1) + +// INSERT INTO X VALUES (1) Datum -pg_spi_insert_int(PG_FUNCTION_ARGS) +pg_spi_insert_int (PG_FUNCTION_ARGS) { int ret; int nargs; @@ -165,30 +174,30 @@ pg_spi_insert_int(PG_FUNCTION_ARGS) Datum values[1]; char *query = "INSERT INTO joseph_test.X (a) VALUES ($1)"; - ret = SPI_connect(); + ret = SPI_connect (); if (ret != SPI_OK_CONNECT) { - elog(ERROR, "SPI_connect failed"); + elog (ERROR, "SPI_connect failed"); } nargs = 1; argtypes[0] = INT4OID; - values[0] = Int32GetDatum(3); + values[0] = Int32GetDatum (3); - ret = SPI_execute_with_args(query, nargs, argtypes, values, NULL, false, 0); + ret = SPI_execute_with_args (query, nargs, argtypes, values, NULL, false, 0); if (ret != SPI_OK_INSERT) { - elog(ERROR, "SPI_execute_with_args failed"); + elog (ERROR, "SPI_execute_with_args failed"); } - SPI_finish(); + SPI_finish (); - PG_RETURN_VOID(); + PG_RETURN_VOID (); } Datum -pg_spi_prepare_insert(PG_FUNCTION_ARGS) +pg_spi_prepare_insert (PG_FUNCTION_ARGS) { static SPIPlanPtr prepared_plan = NULL; int ret; @@ -197,38 +206,41 @@ pg_spi_prepare_insert(PG_FUNCTION_ARGS) Datum values[1]; char *query = "INSERT INTO joseph_test.X (a) VALUES ($1)"; SPIPlanPtr new_plan; - ret = SPI_connect(); + ret = SPI_connect (); if (ret != SPI_OK_CONNECT) { - elog(ERROR, "SPI_connect failed ! \n"); + elog (ERROR, "SPI_connect failed ! \n"); } - if (prepared_plan == NULL) { + if (prepared_plan == NULL) + { argtypes[0] = INT4OID; nargs = 1; - values[0] = Int32GetDatum(3); - new_plan = SPI_prepare(query, nargs, argtypes); + values[0] = Int32GetDatum (3); + new_plan = SPI_prepare (query, nargs, argtypes); if (new_plan== NULL) { - elog(ERROR, "SPI_prepare failed ! \n"); + elog (ERROR, "SPI_prepare failed ! \n"); } - prepared_plan = SPI_saveplan(new_plan); + prepared_plan = SPI_saveplan (new_plan); if (prepared_plan == NULL) { - elog(ERROR, "SPI_saveplan failed ! \n"); + elog (ERROR, "SPI_saveplan failed ! \n"); } } - ret = SPI_execute_plan(prepared_plan, values, NULL, false, 0); + ret = SPI_execute_plan (prepared_plan, values, NULL, false, 0); if (ret != SPI_OK_INSERT) { - elog(ERROR, "SPI_execute_plan failed ! \n"); + elog (ERROR, "SPI_execute_plan failed ! \n"); } - SPI_finish(); + SPI_finish (); - PG_RETURN_VOID(); + PG_RETURN_VOID (); } + + /* Datum pg_spi_prepare_insert_bytea(PG_FUNCTION_ARGS) @@ -278,7 +290,7 @@ pg_spi_prepare_insert_bytea(PG_FUNCTION_ARGS) */ Datum -pg_spi_prepare_insert_without_saveplan(PG_FUNCTION_ARGS) +pg_spi_prepare_insert_without_saveplan (PG_FUNCTION_ARGS) { int ret; int nargs; @@ -286,38 +298,34 @@ pg_spi_prepare_insert_without_saveplan(PG_FUNCTION_ARGS) Datum values[1]; char *query = "INSERT INTO joseph_test.X (a) VALUES ($1)"; SPIPlanPtr new_plan; - ret = SPI_connect(); + ret = SPI_connect (); if (ret != SPI_OK_CONNECT) { - elog(ERROR, "SPI_connect failed"); + elog (ERROR, "SPI_connect failed"); } { argtypes[0] = INT4OID; nargs = 1; - values[0] = Int32GetDatum(3); - new_plan = SPI_prepare(query, nargs, argtypes); + values[0] = Int32GetDatum (3); + new_plan = SPI_prepare (query, nargs, argtypes); if (new_plan== NULL) { - elog(ERROR, "SPI_prepare failed"); + elog (ERROR, "SPI_prepare failed"); } } - ret = SPI_execute_plan(new_plan, values, NULL, false, 0); + ret = SPI_execute_plan (new_plan, values, NULL, false, 0); if (ret != SPI_OK_INSERT) { - elog(ERROR, "SPI_execute_plan failed"); + elog (ERROR, "SPI_execute_plan failed"); } - SPI_finish(); + SPI_finish (); - PG_RETURN_VOID(); + PG_RETURN_VOID (); } - - - - /* Datum pg_spi_select_pair_from_y(PG_FUNCTION_ARGS) @@ -349,7 +357,7 @@ pg_spi_select_pair_from_y(PG_FUNCTION_ARGS) } */ -//SELECT X FROM Y WHERE Z=$1 +// SELECT X FROM Y WHERE Z=$1 /* Datum pg_spi_select_with_cond(PG_FUNCTION_ARGS) @@ -443,7 +451,9 @@ Datum pg_spi_prepare_select_with_cond(PG_FUNCTION_ARGS) { } */ -Datum pg_spi_prepare_select_with_cond_without_saveplan(PG_FUNCTION_ARGS) { +Datum +pg_spi_prepare_select_with_cond_without_saveplan (PG_FUNCTION_ARGS) +{ SPIPlanPtr new_plan; int ret; @@ -454,54 +464,56 @@ Datum pg_spi_prepare_select_with_cond_without_saveplan(PG_FUNCTION_ARGS) { char *query = "SELECT col1 FROM joseph_test.Y WHERE col2 = $1"; int result = 0; - ret = SPI_connect(); + ret = SPI_connect (); if (ret != SPI_OK_CONNECT) - elog(ERROR, "SPI_connect failed ! \n"); + elog (ERROR, "SPI_connect failed ! \n"); { argtypes[0] = INT4OID; nargs = 1; - values[0] = Int32GetDatum(2); //Value col2 + values[0] = Int32GetDatum (2); // Value col2 - new_plan = SPI_prepare(query, nargs, argtypes); + new_plan = SPI_prepare (query, nargs, argtypes); if (new_plan == NULL) - elog(ERROR, "SPI_prepare failed ! \n"); + elog (ERROR, "SPI_prepare failed ! \n"); } - ret = SPI_execute_plan(new_plan, values, NULL, false, 0); + ret = SPI_execute_plan (new_plan, values, NULL, false, 0); - if (ret != SPI_OK_SELECT) { - elog(ERROR, "SPI_execute_plan failed: %d \n", ret); - } + if (ret != SPI_OK_SELECT) + { + elog (ERROR, "SPI_execute_plan failed: %d \n", ret); + } proc = SPI_processed; - if (proc > 0) { + if (proc > 0) + { SPITupleTable *tuptable = SPI_tuptable; TupleDesc tupdesc = tuptable->tupdesc; HeapTuple tuple; int i; - for (i = 0; i < proc; i++) { + for (i = 0; i < proc; i++) + { tuple = tuptable->vals[i]; - for (int j = 1; j <= tupdesc->natts; j++) { - char * value = SPI_getvalue(tuple, tupdesc, j); - result += atoi(value); + for (int j = 1; j <= tupdesc->natts; j++) + { + char *value = SPI_getvalue (tuple, tupdesc, j); + result += atoi (value); } } } - SPI_finish(); - PG_RETURN_INT64(result); + SPI_finish (); + PG_RETURN_INT64 (result); } - - Datum -pg_spi_update_y(PG_FUNCTION_ARGS) +pg_spi_update_y (PG_FUNCTION_ARGS) { int ret; int nargs; @@ -509,34 +521,30 @@ pg_spi_update_y(PG_FUNCTION_ARGS) Datum values[1]; char *query = "UPDATE joseph_test.Y SET col1 = 4 WHERE (col2 = $1)"; - ret = SPI_connect(); + ret = SPI_connect (); if (ret != SPI_OK_CONNECT) { - elog(ERROR, "SPI_connect failed ! \n"); + elog (ERROR, "SPI_connect failed ! \n"); } nargs = 1; argtypes[0] = INT4OID; - values[0] = Int32GetDatum(0); + values[0] = Int32GetDatum (0); - ret = SPI_execute_with_args(query, nargs, argtypes, values, NULL, false, 0); + ret = SPI_execute_with_args (query, nargs, argtypes, values, NULL, false, 0); if (ret != SPI_OK_UPDATE) { - elog(ERROR, "SPI_execute_with_args failed ! \n"); + elog (ERROR, "SPI_execute_with_args failed ! \n"); } - SPI_finish(); + SPI_finish (); - PG_RETURN_VOID(); + PG_RETURN_VOID (); } - - - - Datum -pg_spi_prepare_update(PG_FUNCTION_ARGS) +pg_spi_prepare_update (PG_FUNCTION_ARGS) { static SPIPlanPtr prepared_plan = NULL; SPIPlanPtr new_plan; @@ -546,60 +554,63 @@ pg_spi_prepare_update(PG_FUNCTION_ARGS) Datum values[1]; char *query = "UPDATE joseph_test.Y SET col1 = 4 WHERE (col2 = $1)"; - ret = SPI_connect(); + ret = SPI_connect (); if (ret != SPI_OK_CONNECT) { - elog(ERROR, "SPI_connect failed ! \n"); + elog (ERROR, "SPI_connect failed ! \n"); } - if ( prepared_plan == NULL) + if (prepared_plan == NULL) { argtypes[0] = INT4OID; nargs = 1; - values[0] = Int32GetDatum(3); - //PREPARE - new_plan = SPI_prepare(query, nargs, argtypes); + values[0] = Int32GetDatum (3); + // PREPARE + new_plan = SPI_prepare (query, nargs, argtypes); if (new_plan == NULL) - elog(ERROR, "SPI_prepare failed ! \n"); - //SAVEPLAN - prepared_plan = SPI_saveplan(new_plan); - if(prepared_plan == NULL) - elog(ERROR, "SPI_saveplan failed ! \n"); + elog (ERROR, "SPI_prepare failed ! \n"); + // SAVEPLAN + prepared_plan = SPI_saveplan (new_plan); + if (prepared_plan == NULL) + elog (ERROR, "SPI_saveplan failed ! \n"); } - ret = SPI_execute_plan(prepared_plan, values, NULL, false, 0); + ret = SPI_execute_plan (prepared_plan, values, NULL, false, 0); if (ret != SPI_OK_UPDATE) - elog(ERROR, "SPI_execute_plan failed ! \n"); + elog (ERROR, "SPI_execute_plan failed ! \n"); - SPI_finish(); - PG_RETURN_VOID(); + SPI_finish (); + PG_RETURN_VOID (); } + + /* Datum pg_spi_prepare_update_without_saveplan(PG_FUNCTION_ARGS) {}*/ -void _PG_fini(void) +void +_PG_fini (void) { } + /* */ - - Datum -pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { +pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) +{ /* Define plan to save */ static SPIPlanPtr deposit_plan; static SPIPlanPtr ref_plan; static SPIPlanPtr fees_plan; static SPIPlanPtr dummy_plan; /* Define variables to update */ - Timestamp refund_deadline = PG_GETARG_TIMESTAMP(0); - bytea *merchant_pub = PG_GETARG_BYTEA_P(1); - bytea *wire_target_h_payto = PG_GETARG_BYTEA_P(2); - bytea *wtid_raw = PG_GETARG_BYTEA_P(3); + Timestamp refund_deadline = PG_GETARG_TIMESTAMP (0); + bytea *merchant_pub = PG_GETARG_BYTEA_P (1); + bytea *wire_target_h_payto = PG_GETARG_BYTEA_P (2); + bytea *wtid_raw = PG_GETARG_BYTEA_P (3); bool is_null; /* Define variables to store the results of each SPI query */ uint64_t sum_deposit_val = 0; @@ -632,11 +643,12 @@ pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { bytea *norm_ref_by_coin_coin_pub; int64_t norm_ref_by_coin_deposit_serial_id = 0; bytea *new_dep_coin_pub = NULL; - int res = SPI_connect(); + int res = SPI_connect (); /* Connect to SPI */ - if (res < 0) { - elog(ERROR, "Could not connect to SPI manager"); + if (res < 0) + { + elog (ERROR, "Could not connect to SPI manager"); } if (deposit_plan == NULL) { @@ -655,74 +667,98 @@ pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { "coin_pub," "amount_with_fee_val," "amount_with_fee_frac;"; - fprintf(stderr, "dep sql %d\n", 1); + fprintf (stderr, "dep sql %d\n", 1); new_plan = - SPI_prepare(dep_sql, 4,(Oid[]){INT8OID, BYTEAOID, BYTEAOID}); - fprintf(stderr, "dep sql %d\n", 2); + SPI_prepare (dep_sql, 4,(Oid[]){INT8OID, BYTEAOID, BYTEAOID}); + fprintf (stderr, "dep sql %d\n", 2); if (new_plan == NULL) - elog(ERROR, "SPI_prepare failed for dep \n"); - deposit_plan = SPI_saveplan(new_plan); + elog (ERROR, "SPI_prepare failed for dep \n"); + deposit_plan = SPI_saveplan (new_plan); if (deposit_plan == NULL) - elog(ERROR, "SPI_saveplan failed for dep \n"); + elog (ERROR, "SPI_saveplan failed for dep \n"); } - fprintf(stdout, "dep sql %d\n", 3); + fprintf (stdout, "dep sql %d\n", 3); - values_deposit[0] = Int64GetDatum(refund_deadline); - values_deposit[1] = PointerGetDatum(merchant_pub); - values_deposit[2] = PointerGetDatum(wire_target_h_payto); + values_deposit[0] = Int64GetDatum (refund_deadline); + values_deposit[1] = PointerGetDatum (merchant_pub); + values_deposit[2] = PointerGetDatum (wire_target_h_payto); res = SPI_execute_plan (deposit_plan, values_deposit, NULL, true, 0); - fprintf(stdout, "dep sql %d\n", 4); + fprintf (stdout, "dep sql %d\n", 4); if (res != SPI_OK_UPDATE) { - elog(ERROR, "Failed to execute subquery 1 \n"); + elog (ERROR, "Failed to execute subquery 1 \n"); } // STORE TUPTABLE deposit dep_res = SPI_tuptable; - for (unsigned int i = 0; i < SPI_processed; i++) { - int64 dep_deposit_serial_ids = DatumGetInt64(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &is_null)); - bytea *dep_coin_pub = DatumGetByteaP(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &is_null)); - int64 dep_amount_val = DatumGetInt64(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 3, &is_null)); - int32 dep_amount_frac = DatumGetInt32(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 4, &is_null)); + for (unsigned int i = 0; i < SPI_processed; i++) + { + int64 dep_deposit_serial_ids = DatumGetInt64 (SPI_getbinval ( + SPI_tuptable->vals[i], + SPI_tuptable->tupdesc, 1, + &is_null)); + bytea *dep_coin_pub = DatumGetByteaP (SPI_getbinval (SPI_tuptable->vals[i], + SPI_tuptable->tupdesc, + 2, &is_null)); + int64 dep_amount_val = DatumGetInt64 (SPI_getbinval (SPI_tuptable->vals[i], + SPI_tuptable->tupdesc, + 3, &is_null)); + int32 dep_amount_frac = DatumGetInt32 (SPI_getbinval (SPI_tuptable->vals[i], + SPI_tuptable->tupdesc, + 4, &is_null)); if (is_null) - elog(ERROR, "Failed to retrive data from deposit \n"); + elog (ERROR, "Failed to retrieve data from deposit \n"); if (ref_plan == NULL) { // Execute second query with parameters from first query and store results in variables - const char * ref_sql = + const char *ref_sql = "SELECT amount_with_fee_val, amount_with_fee_frac, coin_pub, deposit_serial_id " "FROM refunds " "WHERE coin_pub=$1 " "AND deposit_serial_id=$2;"; - SPIPlanPtr new_plan = SPI_prepare(ref_sql, 3, (Oid[]){BYTEAOID, INT8OID}); + SPIPlanPtr new_plan = SPI_prepare (ref_sql, 3, (Oid[]){BYTEAOID, + INT8OID}); if (new_plan == NULL) - elog(ERROR, "SPI_prepare failed for refund\n"); - ref_plan = SPI_saveplan(new_plan); + elog (ERROR, "SPI_prepare failed for refund\n"); + ref_plan = SPI_saveplan (new_plan); if (ref_plan == NULL) - elog(ERROR, "SPI_saveplan failed for refund\n"); + elog (ERROR, "SPI_saveplan failed for refund\n"); } - values_refund[0] = PointerGetDatum(dep_coin_pub); - values_refund[1] = Int64GetDatum(dep_deposit_serial_ids); - res = SPI_execute_plan(ref_plan, - values_refund, - NULL, - false, - 0); + values_refund[0] = PointerGetDatum (dep_coin_pub); + values_refund[1] = Int64GetDatum (dep_deposit_serial_ids); + res = SPI_execute_plan (ref_plan, + values_refund, + NULL, + false, + 0); if (res != SPI_OK_SELECT) - elog(ERROR, "Failed to execute subquery 2\n"); + elog (ERROR, "Failed to execute subquery 2\n"); // STORE TUPTABLE refund ref_res = SPI_tuptable; - for (unsigned int j = 0; j < SPI_processed; j++) { - int64 ref_refund_val = DatumGetInt64(SPI_getbinval(SPI_tuptable->vals[j], SPI_tuptable->tupdesc, 1, &is_null)); - int32 ref_refund_frac = DatumGetInt32(SPI_getbinval(SPI_tuptable->vals[j], SPI_tuptable->tupdesc, 2, &is_null)); - bytea *ref_coin_pub = DatumGetByteaP(SPI_getbinval(SPI_tuptable->vals[j], SPI_tuptable->tupdesc, 3, &is_null)); - int64 ref_deposit_serial_id = DatumGetInt64(SPI_getbinval(SPI_tuptable->vals[j], SPI_tuptable->tupdesc, 4, &is_null)); + for (unsigned int j = 0; j < SPI_processed; j++) + { + int64 ref_refund_val = DatumGetInt64 (SPI_getbinval ( + SPI_tuptable->vals[j], + SPI_tuptable->tupdesc, 1, + &is_null)); + int32 ref_refund_frac = DatumGetInt32 (SPI_getbinval ( + SPI_tuptable->vals[j], + SPI_tuptable->tupdesc, 2, + &is_null)); + bytea *ref_coin_pub = DatumGetByteaP (SPI_getbinval ( + SPI_tuptable->vals[j], + SPI_tuptable->tupdesc, 3, + &is_null)); + int64 ref_deposit_serial_id = DatumGetInt64 (SPI_getbinval ( + SPI_tuptable->vals[j], + SPI_tuptable->tupdesc, 4, + &is_null)); // Execute third query with parameters from second query and store results in variables ref_by_coin_coin_pub = ref_coin_pub; ref_by_coin_deposit_serial_id = ref_deposit_serial_id; @@ -730,10 +766,14 @@ pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { for (unsigned int i = 0; ivals[i], SPI_tuptable->tupdesc, 1, &is_null))) + DatumGetByteaP (SPI_getbinval (SPI_tuptable->vals[i], + SPI_tuptable->tupdesc, 1, + &is_null))) && (ref_by_coin_deposit_serial_id == - DatumGetUInt64(SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &is_null))) + DatumGetUInt64 (SPI_getbinval (SPI_tuptable->vals[i], + SPI_tuptable->tupdesc, 2, + &is_null))) ) { sum_refund_val += ref_refund_val; @@ -742,15 +782,15 @@ pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { norm_ref_by_coin_deposit_serial_id = ref_by_coin_deposit_serial_id; } }// END SUM CALCULATION - //NORMALIZE REFUND VAL FRAC + // NORMALIZE REFUND VAL FRAC norm_refund_val = - (sum_refund_val + sum_refund_frac ) / 100000000; + (sum_refund_val + sum_refund_frac) / 100000000; norm_refund_frac = sum_refund_frac % 100000000; // Get refund values s_refund_val += sum_refund_val; s_refund_frac = sum_refund_frac; - }//END REFUND + }// END REFUND if (norm_ref_by_coin_coin_pub == dep_coin_pub && ref_by_coin_deposit_serial_id == dep_deposit_serial_ids && norm_refund_val == dep_amount_val @@ -759,40 +799,46 @@ pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { new_dep_coin_pub = dep_coin_pub; } // Ensure we get the fee for each coin and not only once per denomination - if (fees_plan == NULL ) + if (fees_plan == NULL) { - const char * fees_sql = + const char *fees_sql = "SELECT " " denom.fee_deposit_val AS fee_val, " " denom.fee_deposit_frac AS fee_frac, " "FROM known_coins kc" "JOIN denominations denom USING (denominations_serial) " "WHERE kc.coin_pub = $1 AND kc.coin_pub != $2;"; - SPIPlanPtr new_plan = SPI_prepare(fees_sql, 3, (Oid[]){BYTEAOID, BYTEAOID}); + SPIPlanPtr new_plan = SPI_prepare (fees_sql, 3, (Oid[]){BYTEAOID, + BYTEAOID}); if (new_plan == NULL) - { - elog(ERROR, "SPI_prepare for fees failed ! \n"); - } - fees_plan = SPI_saveplan(new_plan); + { + elog (ERROR, "SPI_prepare for fees failed ! \n"); + } + fees_plan = SPI_saveplan (new_plan); if (fees_plan == NULL) - { - elog(ERROR, "SPI_saveplan for fees failed ! \n"); - } + { + elog (ERROR, "SPI_saveplan for fees failed ! \n"); + } } - values_fees[0] = PointerGetDatum(dep_coin_pub); - values_fees[1] = PointerGetDatum(new_dep_coin_pub); - res = SPI_execute_plan(fees_plan, values_fees, NULL, false, 0); + values_fees[0] = PointerGetDatum (dep_coin_pub); + values_fees[1] = PointerGetDatum (new_dep_coin_pub); + res = SPI_execute_plan (fees_plan, values_fees, NULL, false, 0); if (res != SPI_OK_SELECT) - elog(ERROR, "SPI_execute_plan failed for fees \n"); + elog (ERROR, "SPI_execute_plan failed for fees \n"); fees_res = SPI_tuptable; tupdesc = fees_res->tupdesc; for (unsigned int i = 0; ivals[i]; bool is_null; - uint64_t fee_val = DatumGetUInt64(SPI_getbinval(tuple, tupdesc, 1, &is_null)); - uint32_t fee_frac = DatumGetUInt32(SPI_getbinval(tuple, tupdesc, 2, &is_null)); - uint64_t fees_deposit_serial_id = DatumGetUInt64(SPI_getbinval(tuple, tupdesc, 3, &is_null)); + uint64_t fee_val = DatumGetUInt64 (SPI_getbinval (tuple, tupdesc, 1, + &is_null)); + uint32_t fee_frac = DatumGetUInt32 (SPI_getbinval (tuple, tupdesc, 2, + &is_null)); + uint64_t fees_deposit_serial_id = DatumGetUInt64 (SPI_getbinval (tuple, + tupdesc, + 3, + &is_null)); if (dummy_plan == NULL) { const char *insert_dummy_sql = @@ -800,18 +846,19 @@ pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { "aggregation_tracking(deposit_serial_id, wtid_raw)" " VALUES ($1, $2)"; - SPIPlanPtr new_plan = SPI_prepare(insert_dummy_sql, 2, (Oid[]){INT8OID, BYTEAOID}); + SPIPlanPtr new_plan = SPI_prepare (insert_dummy_sql, 2, (Oid[]){INT8OID, + BYTEAOID}); if (new_plan == NULL) - elog(ERROR, "FAILED to prepare aggregation tracking \n"); - dummy_plan = SPI_saveplan(new_plan); - if ( dummy_plan == NULL ) - elog(ERROR, "FAILED to saveplan aggregation tracking\n"); + elog (ERROR, "FAILED to prepare aggregation tracking \n"); + dummy_plan = SPI_saveplan (new_plan); + if (dummy_plan == NULL) + elog (ERROR, "FAILED to saveplan aggregation tracking\n"); } - values_dummys[0] = Int64GetDatum(dep_deposit_serial_ids); - values_dummys[1] = PointerGetDatum(wtid_raw); - res = SPI_execute_plan(dummy_plan, values_dummys, NULL, false, 0); + values_dummys[0] = Int64GetDatum (dep_deposit_serial_ids); + values_dummys[1] = PointerGetDatum (wtid_raw); + res = SPI_execute_plan (dummy_plan, values_dummys, NULL, false, 0); if (res != SPI_OK_INSERT) - elog(ERROR, "Failed to insert dummy\n"); + elog (ERROR, "Failed to insert dummy\n"); dummys_res = SPI_tuptable; // Calculation of deposit fees for not fully refunded deposits sum_dep_fee_val += fee_val; @@ -820,7 +867,7 @@ pg_spi_get_dep_ref_fees (PG_FUNCTION_ARGS) { // Get deposit values sum_deposit_val += dep_amount_val; sum_deposit_frac += dep_amount_frac; - }//END DEPOSIT - SPI_finish(); - PG_RETURN_VOID(); + }// END DEPOSIT + SPI_finish (); + PG_RETURN_VOID (); } diff --git a/src/exchangedb/spi/pg_aggregate.c b/src/exchangedb/spi/pg_aggregate.c index 262100ce8..721f247c7 100644 --- a/src/exchangedb/spi/pg_aggregate.c +++ b/src/exchangedb/spi/pg_aggregate.c @@ -6,9 +6,10 @@ PG_MODULE_MAGIC; -PG_FUNCTION_INFO_V1(get_deposit_summary); +PG_FUNCTION_INFO_V1 (get_deposit_summary); -Datum get_deposit_summary(PG_FUNCTION_ARGS) +Datum +get_deposit_summary (PG_FUNCTION_ARGS) { static SPIPlanPtr deposit_plan; @@ -18,24 +19,25 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) static SPIPlanPtr fully_refunded_by_coins_plan; static SPIPlanPtr fees_plan; - int shard = PG_GETARG_INT32(0); - char * sql; - char *merchant_pub = text_to_cstring(PG_GETARG_TEXT_P(1)); - char *wire_target_h_payto = text_to_cstring(PG_GETARG_TEXT_P(2)); - char *wtid_raw = text_to_cstring(PG_GETARG_TEXT_P(3)); - int refund_deadline = PG_GETARG_INT32(4); - int conn = SPI_connect(); + int shard = PG_GETARG_INT32 (0); + char *sql; + char *merchant_pub = text_to_cstring (PG_GETARG_TEXT_P (1)); + char *wire_target_h_payto = text_to_cstring (PG_GETARG_TEXT_P (2)); + char *wtid_raw = text_to_cstring (PG_GETARG_TEXT_P (3)); + int refund_deadline = PG_GETARG_INT32 (4); + int conn = SPI_connect (); if (conn != SPI_OK_CONNECT) { - elog(ERROR, "DB connexion failed ! \n"); + elog (ERROR, "DB connection failed ! \n"); } - if ( deposit_plan == NULL - || refund_plan == NULL - || refund_by_coin_plan == NULL - || norm_refund_by_coin_plan = NULL - || fully_refunded_coins_plan = NULL - || fees_plan == NULL ) + if (deposit_plan == NULL + || refund_plan == NULL + || refund_by_coin_plan == NULL + || norm_refund_by_coin_plan = NULL + || fully_refunded_coins_plan = NULL + || fees_plan + == NULL) { if (deposit_plan == NULL) { @@ -57,22 +59,22 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) " ,amount_with_fee_val AS amount_val" " ,amount_with_fee_frac AS amount_frac"; SPIPlanPtr new_plan = - SPI_prepare(dep_sql, 4, argtypes}); + SPI_prepare (dep_sql, 4, argtypes); if (new_plan == NULL) { - elog(ERROR, "SPI_prepare for deposit failed ! \n"); + elog (ERROR, "SPI_prepare for deposit failed ! \n"); } - deposit_plan = SPI_saveplan(new_plan); + deposit_plan = SPI_saveplan (new_plan); if (deposit_plan == NULL) { - elog(ERROR, "SPI_saveplan for deposit failed ! \n"); + elog (ERROR, "SPI_saveplan for deposit failed ! \n"); } } Datum values[4]; - values[0] = Int64GetDatum(refund_deadline); - values[1] = CStringGetDatum(merchant_pub); - values[2] = CStringGetDatum(wire_target_h_payto); + values[0] = Int64GetDatum (refund_deadline); + values[1] = CStringGetDatum (merchant_pub); + values[2] = CStringGetDatum (wire_target_h_payto); int ret = SPI_execute_plan (deposit_plan, values, NULL, @@ -80,22 +82,24 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) 0); if (ret != SPI_OK_UPDATE) { - elog(ERROR, "Failed to execute subquery 1\n"); + elog (ERROR, "Failed to execute subquery 1\n"); } - uint64_t *dep_deposit_serial_ids = palloc(sizeof(uint64_t) * SPI_processed); - BYTEA **dep_coin_pubs = palloc(sizeof(BYTEA *) * SPI_processed); - uint64_t *dep_amount_vals = palloc(sizeof(uint64_t) * SPI_processed); - uint32_t *dep_amount_fracs = palloc(sizeof(uint32_t) * SPI_processed); - for (unsigned int i = 0; i < SPI_processed; i++) { + uint64_t *dep_deposit_serial_ids = palloc (sizeof(uint64_t) + * SPI_processed); + BYTEA **dep_coin_pubs = palloc (sizeof(BYTEA *) * SPI_processed); + uint64_t *dep_amount_vals = palloc (sizeof(uint64_t) * SPI_processed); + uint32_t *dep_amount_fracs = palloc (sizeof(uint32_t) * SPI_processed); + for (unsigned int i = 0; i < SPI_processed; i++) + { HeapTuple tuple = SPI_tuptable->vals[i]; dep_deposit_serial_ids[i] = - DatumGetInt64(SPI_getbinval(tuple, SPI_tuptable->tupdesc, 1, &ret)); + DatumGetInt64 (SPI_getbinval (tuple, SPI_tuptable->tupdesc, 1, &ret)); dep_coin_pubs[i] = - DatumGetByteaP(SPI_getbinval(tuple, SPI_tuptable->tupdesc, 2, &ret)); + DatumGetByteaP (SPI_getbinval (tuple, SPI_tuptable->tupdesc, 2, &ret)); dep_amount_vals[i] = - DatumGetInt64(SPI_getbinval(tuple, SPI_tuptable->tupdesc, 3, &ret)); + DatumGetInt64 (SPI_getbinval (tuple, SPI_tuptable->tupdesc, 3, &ret)); dep_amount_fracs[i] = - DatumGetInt32(SPI_getbinval(tuple, SPI_tuptable->tupdesc, 4, &ret)); + DatumGetInt32 (SPI_getbinval (tuple, SPI_tuptable->tupdesc, 4, &ret)); } @@ -111,45 +115,47 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) " FROM refunds" " WHERE coin_pub IN (SELECT coin_pub FROM dep)" " AND deposit_serial_id IN (SELECT deposit_serial_id FROM dep)) "; - SPIPlanPtr new_plan = SPI_prepare(ref_sql, 0, NULL); + SPIPlanPtr new_plan = SPI_prepare (ref_sql, 0, NULL); if (new_plan == NULL) elog (ERROR, "SPI_prepare for refund failed ! \n"); - refund_plan = SPI_saveplan(new_plan); + refund_plan = SPI_saveplan (new_plan); if (refund_plan == NULL) { - elog(ERROR, "SPI_saveplan for refund failed ! \n"); + elog (ERROR, "SPI_saveplan for refund failed ! \n"); } } - int64t_t *ref_deposit_serial_ids = palloc(sizeof(int64_t) * SPI_processed); + int64t_t *ref_deposit_serial_ids = palloc (sizeof(int64_t) * SPI_processed); int res = SPI_execute_plan (refund_plan, NULL, NULL, false, 0); if (res != SPI_OK_SELECT) { - elog(ERROR, "Failed to execute subquery 2\n"); + elog (ERROR, "Failed to execute subquery 2\n"); } SPITupleTable *tuptable = SPI_tuptable; TupleDesc tupdesc = tuptable->tupdesc; for (unsigned int i = 0; i < SPI_processed; i++) { HeapTuple tuple = tuptable->vals[i]; - Datum refund_val = SPI_getbinval(tuple, tupdesc, 1, &refund_val_isnull); - Datum refund_frac = SPI_getbinval(tuple, tupdesc, 2, &refund_frac_isnull); - Datum coin_pub = SPI_getbinval(tuple, tupdesc, 3, &coin_pub_isnull); - Datum deposit_serial_id = SPI_getbinval(tuple, tupdesc, 4, &deposit_serial_id_isnull); + Datum refund_val = SPI_getbinval (tuple, tupdesc, 1, &refund_val_isnull); + Datum refund_frac = SPI_getbinval (tuple, tupdesc, 2, + &refund_frac_isnull); + Datum coin_pub = SPI_getbinval (tuple, tupdesc, 3, &coin_pub_isnull); + Datum deposit_serial_id = SPI_getbinval (tuple, tupdesc, 4, + &deposit_serial_id_isnull); if (refund_val_isnull || refund_frac_isnull || coin_pub_isnull - || deposit_serial_id_isnull ) + || deposit_serial_id_isnull) { - elog(ERROR, "Failed to retrieve data from subquery 2"); + elog (ERROR, "Failed to retrieve data from subquery 2"); } - uint64_t refund_val_int = DatumGetUInt64(refund_val); - uint32_t refund_frac_int = DatumGetUInt32(refund_frac); - BYTEA coin_pub = DatumGetByteaP(coin_pub); - ref_deposit_serial_ids = DatumGetInt64(deposit_serial_id); + uint64_t refund_val_int = DatumGetUInt64 (refund_val); + uint32_t refund_frac_int = DatumGetUInt32 (refund_frac); + BYTEA coin_pub = DatumGetByteaP (coin_pub); + ref_deposit_serial_ids = DatumGetInt64 (deposit_serial_id); - refund *new_refund = (refund*) palloc(sizeof(refund)); + refund *new_refund = (refund*) palloc (sizeof(refund)); new_refund->coin_pub = coin_pub_str; new_refund->deposit_serial_id = deposit_serial_id_int; new_refund->amount_with_fee_val = refund_val_int; @@ -170,17 +176,17 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) " GROUP BY coin_pub, deposit_serial_id) "; SPIPlanPtr new_plan = SPI_prepare (ref_by_coin_sql, 0, NULL); if (new_plan == NULL) - elog(ERROR, "SPI_prepare for refund by coin failed ! \n"); + elog (ERROR, "SPI_prepare for refund by coin failed ! \n"); refund_by_coin_plan = SPI_saveplan (new_plan); if (refund_by_coin_plan == NULL) - elog(ERROR, "SPI_saveplan for refund failed"); + elog (ERROR, "SPI_saveplan for refund failed"); } int res = SPI_execute_plan (refund_by_coin_plan, NULL, NULL, false, 0); if (res != SPI_OK_SELECT) { - elog(ERROR, "Failed to execute subquery 2\n"); + elog (ERROR, "Failed to execute subquery 2\n"); } SPITupleTable *tuptable = SPI_tuptable; @@ -188,22 +194,25 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) for (unsigned int i = 0; i < SPI_processed; i++) { HeapTuple tuple = tuptable->vals[i]; - Datum sum_refund_val = SPI_getbinval(tuple, tupdesc, 1, &refund_val_isnull); - Datum sum_refund_frac = SPI_getbinval(tuple, tupdesc, 2, &refund_frac_isnull); - Datum coin_pub = SPI_getbinval(tuple, tupdesc, 3, &coin_pub_isnull); - Datum deposit_serial_id_int = SPI_getbinval(tuple, tupdesc, 4, &deposit_serial_id_isnull); + Datum sum_refund_val = SPI_getbinval (tuple, tupdesc, 1, + &refund_val_isnull); + Datum sum_refund_frac = SPI_getbinval (tuple, tupdesc, 2, + &refund_frac_isnull); + Datum coin_pub = SPI_getbinval (tuple, tupdesc, 3, &coin_pub_isnull); + Datum deposit_serial_id_int = SPI_getbinval (tuple, tupdesc, 4, + &deposit_serial_id_isnull); if (refund_val_isnull || refund_frac_isnull || coin_pub_isnull - || deposit_serial_id_isnull ) + || deposit_serial_id_isnull) { - elog(ERROR, "Failed to retrieve data from subquery 2"); + elog (ERROR, "Failed to retrieve data from subquery 2"); } - uint64_t s_refund_val_int = DatumGetUInt64(sum_refund_val); - uint32_t s_refund_frac_int = DatumGetUInt32(sum_refund_frac); - BYTEA coin_pub = DatumGetByteaP(coin_pub); - uint64_t deposit_serial_id_int = DatumGetInt64(deposit_serial_id_int); - refund *new_refund_by_coin = (refund*) palloc(sizeof(refund)); + uint64_t s_refund_val_int = DatumGetUInt64 (sum_refund_val); + uint32_t s_refund_frac_int = DatumGetUInt32 (sum_refund_frac); + BYTEA coin_pub = DatumGetByteaP (coin_pub); + uint64_t deposit_serial_id_int = DatumGetInt64 (deposit_serial_id_int); + refund *new_refund_by_coin = (refund*) palloc (sizeof(refund)); new_refund_by_coin->coin_pub = coin_pub; new_refund_by_coin->deposit_serial_id = deposit_serial_id_int; new_refund_by_coin->refund_amount_with_fee_val = s_refund_val_int; @@ -221,17 +230,17 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) " FROM ref_by_coin) "; SPIPlanPtr new_plan = SPI_prepare (norm_ref_by_coin_sql, 0, NULL); if (new_plan == NULL) - elog(ERROR, "SPI_prepare for norm refund by coin failed ! \n"); - norm_refund_by_coin_plan = SPI_saveplan(new_plan); + elog (ERROR, "SPI_prepare for norm refund by coin failed ! \n"); + norm_refund_by_coin_plan = SPI_saveplan (new_plan); if (norm_refund_by_coin_plan == NULL) - elog(ERROR, "SPI_saveplan for norm refund by coin failed ! \n"); + elog (ERROR, "SPI_saveplan for norm refund by coin failed ! \n"); } double norm_refund_val = - ((double)new_refund_by_coin->refund_amount_with_fee_val - + (double)new_refund_by_coin->refund_amount_with_fee_frac) / 100000000; + ((double) new_refund_by_coin->refund_amount_with_fee_val + + (double) new_refund_by_coin->refund_amount_with_fee_frac) / 100000000; double norm_refund_frac = - (double)new_refund_by_coin->refund_amount_with_fee_frac % 100000000; + (double) new_refund_by_coin->refund_amount_with_fee_frac % 100000000; if (fully_refunded_coins_plan == NULL) { @@ -246,21 +255,21 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) " AND norm.norm_refund_val = dep.amount_val" " AND norm.norm_refund_frac = dep.amount_frac)) "; SPIPlanPtr new_plan = - SPI_prepare(fully_refunded_coins_sql, 0, NULL); + SPI_prepare (fully_refunded_coins_sql, 0, NULL); if (new_plan == NULL) elog (ERROR, "SPI_prepare for fully refunded coins failed ! \n"); - fully_refunded_coins_plan = SPI_saveplan(new_plan); + fully_refunded_coins_plan = SPI_saveplan (new_plan); if (fully_refunded_coins_plan == NULL) elog (ERROR, "SPI_saveplan for fully refunded coins failed ! \n"); } - int res = SPI_execute_plan(fully_refunded_coins_sql); - if ( res != SPI_OK_SELECT) - elog(ERROR, "Failed to execute subquery 4\n"); - SPITupleTable * tuptable = SPI_tuptable; + int res = SPI_execute_plan (fully_refunded_coins_sql); + if (res != SPI_OK_SELECT) + elog (ERROR, "Failed to execute subquery 4\n"); + SPITupleTable *tuptable = SPI_tuptable; TupleDesc tupdesc = tuptable->tupdesc; - BYTEA coin_pub = SPI_getbinval(tuple, tupdesc, 1, &coin_pub_isnull); + BYTEA coin_pub = SPI_getbinval (tuple, tupdesc, 1, &coin_pub_isnull); if (fees_plan == NULL) { const char *fees_sql = @@ -273,26 +282,27 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) "JOIN denominations denom USING (denominations_serial) " "WHERE coin_pub NOT IN (SELECT coin_pub FROM fully_refunded_coins)"; SPIPlanPtr new_plan = - SPI_prepare(fees_sql, 0, NULL); + SPI_prepare (fees_sql, 0, NULL); if (new_plan == NULL) { - elog(ERROR, "SPI_prepare for fees failed ! \n"); + elog (ERROR, "SPI_prepare for fees failed ! \n"); } - fees_plan = SPI_saveplan(new_plan); + fees_plan = SPI_saveplan (new_plan); if (fees_plan == NULL) { - elog(ERROR, "SPI_saveplan for fees failed ! \n"); + elog (ERROR, "SPI_saveplan for fees failed ! \n"); } } } int fees_ntuples; - SPI_execute(fees_sql, true, 0); - if (SPI_result_code() != SPI_OK_SELECT) + SPI_execute (fees_sql, true, 0); + if (SPI_result_code () != SPI_OK_SELECT) { - ereport( - ERROR, - (errcode(ERRCODE_INTERNAL_ERROR), - errmsg("deposit fee query failed: error code %d \n", SPI_result_code()))); + ereport ( + ERROR, + (errcode (ERRCODE_INTERNAL_ERROR), + errmsg ("deposit fee query failed: error code %d \n", + SPI_result_code ()))); } fees_ntuples = SPI_processed; @@ -301,25 +311,28 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) for (i = 0; i < fees_ntuples; i++) { Datum fee_val_datum = - SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &fee_null); + SPI_getbinval (SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, + &fee_null); Datum fee_frac_datum = - SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &fee_null); + SPI_getbinval (SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, + &fee_null); Datum deposit_id_datum = - SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 3, &deposit_null); - if (!fee_null && !deposit_null) + SPI_getbinval (SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 3, + &deposit_null); + if (! fee_null && ! deposit_null) { - int64 fee_val = DatumGetInt64(fee_val_datum); - int32 fee_frac = DatumGetInt32(fee_frac_datum); - int64 deposit_id = DatumGetInt64(deposit_id_datum); + int64 fee_val = DatumGetInt64 (fee_val_datum); + int32 fee_frac = DatumGetInt32 (fee_frac_datum); + int64 deposit_id = DatumGetInt64 (deposit_id_datum); sum_fee_value += fee_val; sum_fee_fraction += fee_frac; char *insert_agg_sql = - psprintf( - "INSERT INTO " - "aggregation_tracking(deposit_serial_id, wtid_raw)" - " VALUES (%lld, '%s')", - deposit_id, wtid_raw); - SPI_execute(insert_agg_sql, false, 0); + psprintf ( + "INSERT INTO " + "aggregation_tracking(deposit_serial_id, wtid_raw)" + " VALUES (%lld, '%s')", + deposit_id, wtid_raw); + SPI_execute (insert_agg_sql, false, 0); } } } @@ -331,33 +344,39 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) if (tuptable == NULL || SPI_processed != 1) { - ereport( - ERROR, - (errcode(ERRCODE_INTERNAL_ERROR), - errmsg("Unexpected result \n"))); + ereport ( + ERROR, + (errcode (ERRCODE_INTERNAL_ERROR), + errmsg ("Unexpected result \n"))); } tupdesc = SPI_tuptable->tupdesc; tuple = SPI_tuptable->vals[0]; - result = HeapTupleGetDatum(tuple); + result = HeapTupleGetDatum (tuple); - TupleDesc result_desc = CreateTemplateTupleDesc(6, false); - TupleDescInitEntry(result_desc, (AttrNumber) 1, "sum_deposit_value", INT8OID, -1, 0); - TupleDescInitEntry(result_desc, (AttrNumber) 2, "sum_deposit_fraction", INT4OID, -1, 0); - TupleDescInitEntry(result_desc, (AttrNumber) 3, "sum_refund_value", INT8OID, -1, 0); - TupleDescInitEntry(result_desc, (AttrNumber) 4, "sum_refund_fraction", INT4OID, -1, 0); - TupleDescInitEntry(result_desc, (AttrNumber) 5, "sum_fee_value", INT8OID, -1, 0); - TupleDescInitEntry(result_desc, (AttrNumber) 6, "sum_fee_fraction", INT4OID, -1, 0); + TupleDesc result_desc = CreateTemplateTupleDesc (6, false); + TupleDescInitEntry (result_desc, (AttrNumber) 1, "sum_deposit_value", INT8OID, + -1, 0); + TupleDescInitEntry (result_desc, (AttrNumber) 2, "sum_deposit_fraction", + INT4OID, -1, 0); + TupleDescInitEntry (result_desc, (AttrNumber) 3, "sum_refund_value", INT8OID, + -1, 0); + TupleDescInitEntry (result_desc, (AttrNumber) 4, "sum_refund_fraction", + INT4OID, -1, 0); + TupleDescInitEntry (result_desc, (AttrNumber) 5, "sum_fee_value", INT8OID, -1, + 0); + TupleDescInitEntry (result_desc, (AttrNumber) 6, "sum_fee_fraction", INT4OID, + -1, 0); - int ret = SPI_prepare(sql, 4, argtypes); + int ret = SPI_prepare (sql, 4, argtypes); if (ret != SPI_OK_PREPARE) { - elog(ERROR, "Failed to prepare statement: %s \n", sql); + elog (ERROR, "Failed to prepare statement: %s \n", sql); } - ret = SPI_execute_plan(plan, args, nulls, true, 0); + ret = SPI_execute_plan (plan, args, nulls, true, 0); if (ret != SPI_OK_SELECT) { - elog(ERROR, "Failed to execute statement: %s \n", sql); + elog (ERROR, "Failed to execute statement: %s \n", sql); } if (SPI_processed > 0) @@ -366,24 +385,27 @@ Datum get_deposit_summary(PG_FUNCTION_ARGS) Datum values[6]; bool nulls[6] = {false}; values[0] = - SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &nulls[0]); + SPI_getbinval (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, + &nulls[0]); values[1] = - SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, &nulls[1]); + SPI_getbinval (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2, + &nulls[1]); values[2] = - SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, &nulls[2]); + SPI_getbinval (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 3, + &nulls[2]); values[3] = - SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 4, &nulls[3]); + SPI_getbinval (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 4, + &nulls[3]); values[4] = - SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 5, &nulls[4]); + SPI_getbinval (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 5, + &nulls[4]); values[5] = - SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 6, &nulls[5]); - tuple = heap_form_tuple(result_desc, values, nulls); - PG_RETURN_DATUM(HeapTupleGetDatum(tuple)); + SPI_getbinval (SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 6, + &nulls[5]); + tuple = heap_form_tuple (result_desc, values, nulls); + PG_RETURN_DATUM (HeapTupleGetDatum (tuple)); } - SPI_finish(); + SPI_finish (); - PG_RETURN_NULL(); + PG_RETURN_NULL (); } - - -