/*
 * src/pl/plpython/plpy_typeio.h
 */

#ifndef PLPY_TYPEIO_H
#define PLPY_TYPEIO_H

#include "access/htup.h"
#include "fmgr.h"
#include "utils/typcache.h"

#include "plpython.h"

struct PLyProcedure;			/* avoid requiring plpy_procedure.h here */


/*
 * "Input" conversion from PostgreSQL Datum to a Python object.
 *
 * arg is the previously-set-up conversion data, val is the value to convert.
 * val mustn't be NULL.
 *
 * Note: the conversion data structs should be regarded as private to
 * plpy_typeio.c.  We declare them here only so that other modules can
 * define structs containing them.
 */
typedef struct PLyDatumToOb PLyDatumToOb;	/* forward reference */

typedef PyObject *(*PLyDatumToObFunc) (PLyDatumToOb *arg, Datum val);

typedef struct PLyScalarToOb
{
	FmgrInfo	typfunc;		/* lookup info for type's output function */
} PLyScalarToOb;

typedef struct PLyArrayToOb
{
	PLyDatumToOb *elm;			/* conversion info for array's element type */
} PLyArrayToOb;

typedef struct PLyTupleToOb
{
	/* If we're dealing with a RECORD type, actual descriptor is here: */
	TupleDesc	recdesc;
	/* If we're dealing with a named composite type, these fields are set: */
	TypeCacheEntry *typentry;	/* typcache entry for type */
	uint64		tupdescid;		/* last tupdesc identifier seen in typcache */
	/* These fields are NULL/0 if not yet set: */
	PLyDatumToOb *atts;			/* array of per-column conversion info */
	int			natts;			/* length of array */
} PLyTupleToOb;

typedef struct PLyTransformToOb
{
	FmgrInfo	typtransform;	/* lookup info for from-SQL transform func */
} PLyTransformToOb;

struct PLyDatumToOb
{
	PLyDatumToObFunc func;		/* conversion control function */
	Oid			typoid;			/* OID of the source type */
	int32		typmod;			/* typmod of the source type */
	bool		typbyval;		/* its physical representation details */
	int16		typlen;
	char		typalign;
	MemoryContext mcxt;			/* context this info is stored in */
	union						/* conversion-type-specific data */
	{
		PLyScalarToOb scalar;
		PLyArrayToOb array;
		PLyTupleToOb tuple;
		PLyTransformToOb transform;
	}			u;
};

/*
 * "Output" conversion from Python object to a PostgreSQL Datum.
 *
 * arg is the previously-set-up conversion data, val is the value to convert.
 *
 * *isnull is set to true if val is Py_None, false otherwise.
 * (The conversion function *must* be called even for Py_None,
 * so that domain constraints can be checked.)
 *
 * inarray is true if the converted value was in an array (Python list).
 * It is used to give a better error message in some cases.
 */
typedef struct PLyObToDatum PLyObToDatum;	/* forward reference */

typedef Datum (*PLyObToDatumFunc) (PLyObToDatum *arg, PyObject *val,
								   bool *isnull,
								   bool inarray);

typedef struct PLyObToScalar
{
	FmgrInfo	typfunc;		/* lookup info for type's input function */
	Oid			typioparam;		/* argument to pass to it */
} PLyObToScalar;

typedef struct PLyObToArray
{
	PLyObToDatum *elm;			/* conversion info for array's element type */
	Oid			elmbasetype;	/* element base type */
} PLyObToArray;

typedef struct PLyObToTuple
{
	/* If we're dealing with a RECORD type, actual descriptor is here: */
	TupleDesc	recdesc;
	/* If we're dealing with a named composite type, these fields are set: */
	TypeCacheEntry *typentry;	/* typcache entry for type */
	uint64		tupdescid;		/* last tupdesc identifier seen in typcache */
	/* These fields are NULL/0 if not yet set: */
	PLyObToDatum *atts;			/* array of per-column conversion info */
	int			natts;			/* length of array */
	/* We might need to convert using record_in(); if so, cache info here */
	FmgrInfo	recinfunc;		/* lookup info for record_in */
} PLyObToTuple;

typedef struct PLyObToDomain
{
	PLyObToDatum *base;			/* conversion info for domain's base type */
	void	   *domain_info;	/* cache space for domain_check() */
} PLyObToDomain;

typedef struct PLyObToTransform
{
	FmgrInfo	typtransform;	/* lookup info for to-SQL transform function */
} PLyObToTransform;

struct PLyObToDatum
{
	PLyObToDatumFunc func;		/* conversion control function */
	Oid			typoid;			/* OID of the target type */
	int32		typmod;			/* typmod of the target type */
	bool		typbyval;		/* its physical representation details */
	int16		typlen;
	char		typalign;
	MemoryContext mcxt;			/* context this info is stored in */
	union						/* conversion-type-specific data */
	{
		PLyObToScalar scalar;
		PLyObToArray array;
		PLyObToTuple tuple;
		PLyObToDomain domain;
		PLyObToTransform transform;
	}			u;
};


extern PyObject *PLy_input_convert(PLyDatumToOb *arg, Datum val);
extern Datum PLy_output_convert(PLyObToDatum *arg, PyObject *val,
								bool *isnull);

extern PyObject *PLy_input_from_tuple(PLyDatumToOb *arg, HeapTuple tuple,
									  TupleDesc desc, bool include_generated);

extern void PLy_input_setup_func(PLyDatumToOb *arg, MemoryContext arg_mcxt,
								 Oid typeOid, int32 typmod,
								 struct PLyProcedure *proc);
extern void PLy_output_setup_func(PLyObToDatum *arg, MemoryContext arg_mcxt,
								  Oid typeOid, int32 typmod,
								  struct PLyProcedure *proc);

extern void PLy_input_setup_tuple(PLyDatumToOb *arg, TupleDesc desc,
								  struct PLyProcedure *proc);
extern void PLy_output_setup_tuple(PLyObToDatum *arg, TupleDesc desc,
								   struct PLyProcedure *proc);

extern void PLy_output_setup_record(PLyObToDatum *arg, TupleDesc desc,
									struct PLyProcedure *proc);

/* conversion from Python objects to C strings --- exported for transforms */
extern char *PLyObject_AsString(PyObject *plrv);

#endif							/* PLPY_TYPEIO_H */