arrays_input.c File Reference

#include "c_common/arrays_input.h"
#include <assert.h>
#include <utils/lsyscache.h>
#include <catalog/pg_type.h>
#include "c_common/time_msg.h"
#include "c_common/debug_macro.h"

Include dependency graph for arrays_input.c:

Go to the source code of this file.

Functions
static int64_t *	pgr_get_bigIntArr (ArrayType *v, size_t *arrlen, bool allow_empty)
	Function for array input. More...
int64_t *	pgr_get_bigIntArray (size_t *arrlen, ArrayType *input)
	Enforces the input array to be NOT empty. More...
int64_t *	pgr_get_bigIntArray_allowEmpty (size_t *arrlen, ArrayType *input)
	Allows the input array to be empty. More...

Function Documentation

pgr_get_bigIntArr()

static int64_t* pgr_get_bigIntArr ( ArrayType *  v, size_t *  arrlen, bool  allow_empty  )

static

Function for array input.

This function generates the array inputs according to their type received through ArrayType *v parameter and store them in c_array. It can be empty also if received allow_empty true. The cases of failure are:-

1. When ndim is not equal to one dimension.
2. When no element is found i.e. nitems is zero or negative.
3. If the element type doesn't lie in switch cases, give the error of expected array of any integer type
4. When size of c_array is out of range or memory.
5. When null value is found in the array.

All these failures are represented as error through elog.

Parameters

[in]	v	The type of element to be processed.
[out]	arrlen	The length of the array (To be determined in this function).
[in]	allow_empty	Bool type parameter that tells us whether to consider empty array or not.

Precondition

The initial value of *arrlen should be zero.

Returns

The resultant array i.e. c_array.

Definition at line 54 of file arrays_input.c.

                                                                  {
    clock_t start_t = clock();
    int64_t *c_array = NULL;
 
    Oid     element_type = ARR_ELEMTYPE(v);
    int    *dim = ARR_DIMS(v);
    int     ndim = ARR_NDIM(v);
    int     nitems = ArrayGetNItems(ndim, dim);
    Datum  *elements;
    bool   *nulls;
    int16   typlen;
    bool    typbyval;
    char    typalign;
 
    assert((*arrlen) == 0);
 
 
    if (allow_empty && (ndim == 0 || nitems <= 0)) {
        PGR_DBG("ndim %i nitems % i", ndim, nitems);
        return (int64_t*)NULL;
    }
    /* the array is not empty*/
 
    if (ndim != 1) {
        elog(ERROR, "One dimension expected");
        return (int64_t*)NULL;
    }
 
    if (nitems <= 0) {
        elog(ERROR, "No elements found");
        return (int64_t*)NULL;
    }
 
    get_typlenbyvalalign(element_type,
            &typlen, &typbyval, &typalign);
 
    /* validate input data type */
    switch (element_type) {
        case INT2OID:
        case INT4OID:
        case INT8OID:
            break;
        default:
            elog(ERROR, "Expected array of ANY-INTEGER");
            return (int64_t*)NULL;
            break;
    }
 
    deconstruct_array(v, element_type, typlen, typbyval,
            typalign, &elements, &nulls,
            &nitems);
 
    c_array = (int64_t *) palloc(sizeof(int64_t) * (size_t)nitems);
    if (!c_array) {
        elog(ERROR, "Out of memory!");
    }
 
 
    int i;
    for (i = 0; i < nitems; i++) {
        if (nulls[i]) {
            pfree(c_array);
            elog(ERROR, "NULL value found in Array!");
        } else {
            switch (element_type) {
                case INT2OID:
                    c_array[i] = (int64_t) DatumGetInt16(elements[i]);
                    break;
                case INT4OID:
                    c_array[i] = (int64_t) DatumGetInt32(elements[i]);
                    break;
                case INT8OID:
                    c_array[i] = DatumGetInt64(elements[i]);
                    break;
            }
        }
    }
    (*arrlen) = (size_t)nitems;
 
    pfree(elements);
    pfree(nulls);
    PGR_DBG("Array size %ld", (*arrlen));
    time_msg("reading Array", start_t, clock());
    return c_array;
}

References PGR_DBG, and time_msg().

Referenced by pgr_get_bigIntArray(), and pgr_get_bigIntArray_allowEmpty().

pgr_get_bigIntArray()

int64_t* pgr_get_bigIntArray	(	size_t *	arrlen,
		ArrayType *	input
	)

Enforces the input array to be NOT empty.

Parameters

[out]	arrlen	Length of the array
[in]	input	Input type of the array

Returns

Returns the output of pgr_get_bitIntArray when allow_empty is set to false.

Definition at line 146 of file arrays_input.c.

                                                               {
    return pgr_get_bigIntArr(input, arrlen, false);
}

References pgr_get_bigIntArr().

Referenced by compute_trsp(), pgr_SPI_getBigIntArr(), and process().

pgr_get_bigIntArray_allowEmpty()

int64_t* pgr_get_bigIntArray_allowEmpty	(	size_t *	arrlen,
		ArrayType *	input
	)

Allows the input array to be empty.

Parameters

[out]	arrlen	Length of the array
[in]	input	Input type of the array

Returns

Returns the output of pgr_get_bitIntArray when allow_empty is set to true.

Definition at line 156 of file arrays_input.c.

                                                                          {
    return pgr_get_bigIntArr(input, arrlen, true);
}

References pgr_get_bigIntArr().

Referenced by process().