/*
* org.postgresql.pljava.Relation type.
*/
jobject Relation_create(Relation td)
{
return (td == 0) ? 0 : JNI_newObject(
s_Relation_class,
s_Relation_init,
Invocation_createLocalWrapper(td));
}
jobject TupleTable_createFromSlot(TupleTableSlot* tts)
{
HeapTuple tuple;
jobject tupdesc;
jobjectArray tuples;
MemoryContext curr;
if(tts == 0)
return 0;
curr = MemoryContextSwitchTo(JavaMemoryContext);
#if (PGSQL_MAJOR_VER == 8 && PGSQL_MINOR_VER == 0)
tupdesc = TupleDesc_internalCreate(tts->ttc_tupleDescriptor);
tuple = heap_copytuple(tts->val);
#else
tupdesc = TupleDesc_internalCreate(tts->tts_tupleDescriptor);
tuple = ExecCopySlotTuple(tts);
#endif
tuples = Tuple_createArray(&tuple, 1, false);
MemoryContextSwitchTo(curr);
return JNI_newObject(s_TupleTable_class, s_TupleTable_init, tupdesc, tuples);
}
jobject SQLInputFromChunk_create(void* data, size_t sz)
{
Ptr2Long p2l;
p2l.longVal = 0L; /* ensure that the rest is zeroed out */
p2l.ptrVal = data;
return JNI_newObject(s_SQLInputFromChunk_class, s_SQLInputFromChunk_init, p2l.longVal, (jint)sz);
}
jobject TriggerData_create(TriggerData* triggerData)
{
return (triggerData == 0) ? 0 : JNI_newObject(
s_TriggerData_class,
s_TriggerData_init,
Invocation_createLocalWrapper(triggerData));
}
static jobject coerceTupleDatum(UDT udt, Datum arg)
{
jobject result = JNI_newObject(Type_getJavaClass((Type)udt), udt->init);
jobject inputStream = SQLInputFromTuple_create(DatumGetHeapTupleHeader(arg), udt->tupleDesc);
JNI_callVoidMethod(result, udt->readSQL, inputStream, udt->sqlTypeName);
JNI_deleteLocalRef(inputStream);
return result;
}
static jobject coerceScalarDatum(UDT self, Datum arg)
{
jobject result;
int32 dataLen = Type_getLength((Type)self);
jclass javaClass = Type_getJavaClass((Type)self);
bool isJavaBasedScalar = 0 != self->toString;
if(dataLen == -2)
{
/* Data is a zero terminated string
*/
jstring jstr = String_createJavaStringFromNTS(DatumGetCString(arg));
result = JNI_callStaticObjectMethod(javaClass, self->parse, jstr, self->sqlTypeName);
JNI_deleteLocalRef(jstr);
}
else
{
char* data;
jobject inputStream;
if(dataLen == -1)
{
/* Data is a varlena struct
*/
bytea* bytes = DatumGetByteaP(arg);
dataLen = VARSIZE(bytes) - VARHDRSZ;
data = VARDATA(bytes);
}
else
{
bool passByValue = Type_isByValue((Type)self);
/* Data is a binary chunk of size dataLen
*/
if (passByValue)
{
/* pass by value data is stored in the least
* significant bits of a Datum. */
#ifdef WORDS_BIGENDIAN
data = ((char *)(&arg)) + SIZEOF_DATUM - dataLen;
#else
data = ((char *)(&arg));
#endif
}
else
{
data = DatumGetPointer(arg);
}
}
result = JNI_newObject(javaClass, self->init);
inputStream = SQLInputFromChunk_create(data, dataLen,
isJavaBasedScalar);
JNI_callVoidMethod(result, self->readSQL, inputStream, self->sqlTypeName);
SQLInputFromChunk_close(inputStream);
}
return result;
}
jobject TupleDesc_internalCreate(TupleDesc td)
{
jobject jtd;
Ptr2Long tdH;
td = CreateTupleDescCopyConstr(td);
tdH.longVal = 0L; /* ensure that the rest is zeroed out */
tdH.ptrVal = td;
jtd = JNI_newObject(s_TupleDesc_class, s_TupleDesc_init, tdH.longVal, (jint)td->natts);
return jtd;
}
static jobject coerceTupleDatum(UDT udt, Datum arg)
{
jobject result = JNI_newObject(Type_getJavaClass((Type)udt), udt->init);
Oid typeId = ((Type)udt)->typeId;
TupleDesc tupleDesc = lookup_rowtype_tupdesc_noerror(typeId, -1, true);
jobject inputStream =
SQLInputFromTuple_create(DatumGetHeapTupleHeader(arg), tupleDesc);
ReleaseTupleDesc(tupleDesc);
JNI_callVoidMethod(result, udt->readSQL, inputStream, udt->sqlTypeName);
JNI_deleteLocalRef(inputStream);
return result;
}
jobject Tuple_internalCreate(HeapTuple ht, bool mustCopy)
{
jobject jht;
Ptr2Long htH;
if(mustCopy)
ht = heap_copytuple(ht);
htH.longVal = 0L; /* ensure that the rest is zeroed out */
htH.ptrVal = ht;
jht = JNI_newObject(s_Tuple_class, s_Tuple_init, htH.longVal);
return jht;
}
/*
* org.postgresql.pljava.type.LargeObject type.
*/
jobject LargeObject_create(LargeObjectDesc* lo)
{
jobject jlo;
Ptr2Long loH;
if(lo == 0)
return 0;
loH.longVal = 0L; /* ensure that the rest is zeroed out */
loH.ptrVal = lo;
jlo = JNI_newObject(s_LargeObject_class, s_LargeObject_init, loH.longVal);
return jlo;
}
jobject ErrorData_getCurrentError(void)
{
Ptr2Long p2l;
jobject jed;
MemoryContext curr = MemoryContextSwitchTo(JavaMemoryContext);
ErrorData* errorData = CopyErrorData();
MemoryContextSwitchTo(curr);
p2l.longVal = 0L; /* ensure that the rest is zeroed out */
p2l.ptrVal = errorData;
jed = JNI_newObject(s_ErrorData_class, s_ErrorData_init, p2l.longVal);
return jed;
}
jobject TupleTable_create(SPITupleTable* tts, jobject knownTD)
{
jobjectArray tuples;
MemoryContext curr;
if(tts == 0)
return 0;
curr = MemoryContextSwitchTo(JavaMemoryContext);
if(knownTD == 0)
knownTD = TupleDesc_internalCreate(tts->tupdesc);
tuples = Tuple_createArray(tts->vals, (jint)(tts->alloced - tts->free), true);
MemoryContextSwitchTo(curr);
return JNI_newObject(s_TupleTable_class, s_TupleTable_init, knownTD, tuples);
}
jobject TupleTable_createFromSlot(TupleTableSlot* tts)
{
HeapTuple tuple;
jobject tupdesc;
jobjectArray tuples;
MemoryContext curr;
if(tts == 0)
return 0;
curr = MemoryContextSwitchTo(JavaMemoryContext);
tupdesc = TupleDesc_internalCreate(tts->tts_tupleDescriptor);
tuple = ExecCopySlotHeapTuple(tts);
tuples = Tuple_createArray(&tuple, 1, false);
MemoryContextSwitchTo(curr);
return JNI_newObject(s_TupleTable_class, s_TupleTable_init, tupdesc, tuples);
}
static jvalue Timestamp_coerceDatumTZ_dd(Type self, Datum arg, bool tzAdjust)
{
jlong mSecs;
jint uSecs;
jvalue result;
double ts = DatumGetFloat8(arg);
int tz = Timestamp_getTimeZone_dd(ts);
/* Expect <seconds since Jan 01 2000>.<fractions of seconds>
*/
if(tzAdjust)
ts += tz; /* Adjust from local time to UTC */
ts += EPOCH_DIFF; /* Adjust for diff between Postgres and Java (Unix) */
mSecs = (jlong) floor(ts * 1000.0); /* Convert to millisecs */
uSecs = (jint) ((ts - floor(ts)) * 1000000.0); /* Preserve microsecs */
result.l = JNI_newObject(s_Timestamp_class, s_Timestamp_init, mSecs);
if(uSecs != 0)
JNI_callVoidMethod(result.l, s_Timestamp_setNanos, uSecs * 1000);
return result;
}
static jvalue Timestamp_coerceDatumTZ_id(Type self, Datum arg, bool tzAdjust)
{
jvalue result;
int64 ts = DatumGetInt64(arg);
int tz = Timestamp_getTimeZone_id(ts);
/* Expect number of microseconds since 01 Jan 2000
*/
jlong mSecs = ts / 1000; /* Convert to millisecs */
jint uSecs = (jint)(ts % 1000000); /* preserve microsecs */
if(tzAdjust)
mSecs += tz * 1000; /* Adjust from local time to UTC */
/* Adjust for diff between Postgres and Java (Unix) */
mSecs += ((jlong)EPOCH_DIFF) * 1000L;
result.l = JNI_newObject(s_Timestamp_class, s_Timestamp_init, mSecs);
if(uSecs != 0)
JNI_callVoidMethod(result.l, s_Timestamp_setNanos, uSecs * 1000);
return result;
}
static jvalue _Integer_coerceDatum(Type self, Datum arg)
{
jvalue result;
result.l = JNI_newObject(s_Integer_class, s_Integer_init, DatumGetInt32(arg));
return result;
}
/*
* org.postgresql.pljava.type.AclId type.
*/
jobject AclId_create(AclId aclId)
{
return JNI_newObject(s_AclId_class, s_AclId_init, (jint)aclId);
}
static jvalue _Double_coerceDatum(Type self, Datum arg)
{
jvalue result;
result.l = JNI_newObject(s_Double_class, s_Double_init, DatumGetFloat8(arg));
return result;
}
static jvalue _Boolean_coerceDatum(Type self, Datum arg)
{
jvalue result;
result.l = JNI_newObject(s_Boolean_class, s_Boolean_init, DatumGetBool(arg));
return result;
}
