static Datum _Type_nextSRF(Type self, jobject rowProducer, jobject rowCollector)
{
jobject tmp = JNI_callObjectMethod(rowProducer, s_Iterator_next);
Datum result = Type_coerceObject(self, tmp);
JNI_deleteLocalRef(tmp);
return result;
}
Datum UDT_output(UDT udt, PG_FUNCTION_ARGS)
{
char* txt;
if(!UDT_isScalar(udt))
ereport(ERROR, (
errcode(ERRCODE_CANNOT_COERCE),
errmsg("UDT with Oid %d is not scalar", Type_getOid((Type)udt))));
if(Type_getLength((Type)udt) == -2)
{
txt = PG_GETARG_CSTRING(0);
if(txt != 0)
txt = pstrdup(txt);
}
else
{
jobject value = _UDT_coerceDatum((Type)udt, PG_GETARG_DATUM(0)).l;
jstring jstr = (jstring)JNI_callObjectMethod(value, udt->toString);
MemoryContext currCtx = Invocation_switchToUpperContext();
txt = String_createNTS(jstr);
MemoryContextSwitchTo(currCtx);
JNI_deleteLocalRef(value);
JNI_deleteLocalRef(jstr);
}
PG_RETURN_CSTRING(txt);
}
Datum _String_coerceObject(Type self, jobject jstr)
{
char* tmp;
Datum ret;
if(jstr == 0)
return 0;
jstr = JNI_callObjectMethod(jstr, s_Object_toString);
if(JNI_exceptionCheck())
return 0;
tmp = String_createNTS(jstr);
JNI_deleteLocalRef(jstr);
ret = FunctionCall3(
&((String)self)->textInput,
CStringGetDatum(tmp),
ObjectIdGetDatum(((String)self) -> Type_extension.typeId /* elementType */ ),
Int32GetDatum(-1));
pfree(tmp);
return ret;
}
Type Type_fromOid(Oid typeId, jobject typeMap)
{
CacheEntry ce;
HeapTuple typeTup;
Form_pg_type typeStruct;
Type type = Type_fromOidCache(typeId);
if(type != 0)
return type;
typeTup = PgObject_getValidTuple(TYPEOID, typeId, "type");
typeStruct = (Form_pg_type)GETSTRUCT(typeTup);
if(typeStruct->typelem != 0 && typeStruct->typlen == -1)
{
type = Type_getArrayType(Type_fromOid(typeStruct->typelem, typeMap), typeId);
goto finally;
}
/* For some reason, the anyarray is *not* an array with anyelement as the
* element type. We'd like to see it that way though.
*/
if(typeId == ANYARRAYOID)
{
type = Type_getArrayType(Type_fromOid(ANYELEMENTOID, typeMap), typeId);
goto finally;
}
if(typeStruct->typbasetype != 0)
{
/* Domain type, recurse using the base type (which in turn may
* also be a domain)
*/
type = Type_fromOid(typeStruct->typbasetype, typeMap);
goto finally;
}
if(typeMap != 0)
{
jobject joid = Oid_create(typeId);
jclass typeClass = (jclass)JNI_callObjectMethod(typeMap, s_Map_get, joid);
JNI_deleteLocalRef(joid);
if(typeClass != 0)
{
TupleDesc tupleDesc = lookup_rowtype_tupdesc_noerror(typeId, -1, true);
type = (Type)UDT_registerUDT(typeClass, typeId, typeStruct, tupleDesc, false);
JNI_deleteLocalRef(typeClass);
goto finally;
}
}
/* Composite and record types will not have a TypeObtainer registered
*/
if(typeStruct->typtype == 'c' || (typeStruct->typtype == 'p' && typeId == RECORDOID))
{
type = Composite_obtain(typeId);
goto finally;
}
ce = (CacheEntry)HashMap_getByOid(s_obtainerByOid, typeId);
if(ce == 0)
/*
* Default to String and standard textin/textout coersion.
*/
type = String_obtain(typeId);
else
{
type = ce->type;
if(type == 0)
type = ce->obtainer(typeId);
}
finally:
ReleaseSysCache(typeTup);
Type_cacheByOid(typeId, type);
return type;
}
static void Function_init(Function self, ParseResult info, Form_pg_proc procStruct, PG_FUNCTION_ARGS)
{
StringInfoData sign;
jobject loader;
jstring className;
/* Get the ClassLoader for the schema that this function belongs to
*/
jstring schemaName = getSchemaName(procStruct->pronamespace);
/* Install the type map for the current schema. This must be done ASAP since
* many other functions (including obtaining the loader) depends on it.
*/
jobject tmp = JNI_callStaticObjectMethod(s_Loader_class, s_Loader_getTypeMap, schemaName);
self->func.nonudt.typeMap = JNI_newGlobalRef(tmp);
JNI_deleteLocalRef(tmp);
self->readOnly = (procStruct->provolatile != PROVOLATILE_VOLATILE);
self->isUDT = info->isUDT;
currentInvocation->function = self;
/* Get the ClassLoader for the schema that this function belongs to
*/
loader = JNI_callStaticObjectMethod(s_Loader_class, s_Loader_getSchemaLoader, schemaName);
JNI_deleteLocalRef(schemaName);
elog(DEBUG1, "Loading class %s", info->className);
className = String_createJavaStringFromNTS(info->className);
tmp = JNI_callObjectMethod(loader, s_ClassLoader_loadClass, className);
JNI_deleteLocalRef(loader);
JNI_deleteLocalRef(className);
self->clazz = (jclass)JNI_newGlobalRef(tmp);
JNI_deleteLocalRef(tmp);
if(self->isUDT)
{
setupUDT(self, info, procStruct);
return;
}
if(CALLED_AS_TRIGGER(fcinfo))
{
self->func.nonudt.typeMap = 0;
setupTriggerParams(self, info);
}
else
{
setupFunctionParams(self, info, procStruct, fcinfo);
}
initStringInfo(&sign);
buildSignature(self, &sign, self->func.nonudt.returnType, false);
elog(DEBUG1, "Obtaining method %s.%s %s", info->className, info->methodName, sign.data);
self->func.nonudt.method = JNI_getStaticMethodIDOrNull(self->clazz, info->methodName, sign.data);
if(self->func.nonudt.method == 0)
{
char* origSign = sign.data;
Type altType = 0;
Type realRetType = self->func.nonudt.returnType;
elog(DEBUG1, "Method %s.%s %s not found", info->className, info->methodName, origSign);
if(Type_isPrimitive(self->func.nonudt.returnType))
{
/*
* One valid reason for not finding the method is when
* the return type used in the signature is a primitive and
* the true return type of the method is the object class that
* corresponds to that primitive.
*/
altType = Type_getObjectType(self->func.nonudt.returnType);
realRetType = altType;
}
else if(strcmp(Type_getJavaTypeName(self->func.nonudt.returnType), "java.sql.ResultSet") == 0)
{
/*
* Another reason might be that we expected a ResultSetProvider
* but the implementation returns a ResultSetHandle that needs to be
* wrapped. The wrapping is internal so we retain the original
* return type anyway.
*/
altType = realRetType;
}
if(altType != 0)
{
JNI_exceptionClear();
initStringInfo(&sign);
buildSignature(self, &sign, altType, true);
elog(DEBUG1, "Obtaining method %s.%s %s", info->className, info->methodName, sign.data);
self->func.nonudt.method = JNI_getStaticMethodIDOrNull(self->clazz, info->methodName, sign.data);
if(self->func.nonudt.method != 0)
self->func.nonudt.returnType = realRetType;
}
if(self->func.nonudt.method == 0)
PgObject_throwMemberError(self->clazz, info->methodName, origSign, true, true);
if(sign.data != origSign)
pfree(origSign);
}
pfree(sign.data);
}
static Datum coerceScalarObject(UDT self, jobject value)
{
Datum result;
int32 dataLen = Type_getLength((Type)self);
if(dataLen == -2)
{
jstring jstr = (jstring)JNI_callObjectMethod(value, self->toString);
char* tmp = String_createNTS(jstr);
result = CStringGetDatum(tmp);
JNI_deleteLocalRef(jstr);
}
else
{
jobject outputStream;
StringInfoData buffer;
bool passByValue = Type_isByValue((Type)self);
MemoryContext currCtx = Invocation_switchToUpperContext();
initStringInfo(&buffer);
if(dataLen < 0)
/*
* Reserve space for an int32 at the beginning. We are building
* a varlena
*/
appendBinaryStringInfo(&buffer, (char*)&dataLen, sizeof(int32));
outputStream = SQLOutputToChunk_create(&buffer);
JNI_callVoidMethod(value, self->writeSQL, outputStream);
SQLOutputToChunk_close(outputStream);
MemoryContextSwitchTo(currCtx);
if(dataLen < 0)
{
/* Assign the correct length.
*/
#if PG_VERSION_NUM < 80300
VARATT_SIZEP(buffer.data) = buffer.len;
#else
SET_VARSIZE(buffer.data, buffer.len);
#endif
}
else if(dataLen != buffer.len)
{
ereport(ERROR, (
errcode(ERRCODE_CANNOT_COERCE),
errmsg("UDT for Oid %d produced image with incorrect size. Expected %d, was %d",
Type_getOid((Type)self), dataLen, buffer.len)));
}
if (passByValue) {
memset(&result, 0, SIZEOF_DATUM);
/* pass by value data is stored in the least
* significant bits of a Datum. */
#ifdef WORDS_BIGENDIAN
memcpy(&result + SIZEOF_DATUM - dataLen, buffer.data, dataLen);
#else
memcpy(&result, buffer.data, dataLen);
#endif
} else {
result = PointerGetDatum(buffer.data);
}
}
return result;
}
/* Make this datatype available to the postgres system.
*/
UDT UDT_registerUDT(jclass clazz, Oid typeId, Form_pg_type pgType, TupleDesc td, bool isJavaBasedScalar)
{
jstring jcn;
MemoryContext currCtx;
HeapTuple nspTup;
Form_pg_namespace nspStruct;
TypeClass udtClass;
UDT udt;
Size signatureLen;
jstring sqlTypeName;
char* className;
char* classSignature;
char* sp;
const char* cp;
const char* tp;
char c;
Type existing = Type_fromOidCache(typeId);
if(existing != 0)
{
if(existing->typeClass->coerceDatum != _UDT_coerceDatum)
{
ereport(ERROR, (
errcode(ERRCODE_CANNOT_COERCE),
errmsg("Attempt to register UDT with Oid %d failed. Oid appoints a non UDT type", typeId)));
}
return (UDT)existing;
}
nspTup = PgObject_getValidTuple(NAMESPACEOID, pgType->typnamespace, "namespace");
nspStruct = (Form_pg_namespace)GETSTRUCT(nspTup);
/* Concatenate namespace + '.' + typename
*/
cp = NameStr(nspStruct->nspname);
tp = NameStr(pgType->typname);
sp = palloc(strlen(cp) + strlen(tp) + 2);
sprintf(sp, "%s.%s", cp, tp);
sqlTypeName = String_createJavaStringFromNTS(sp);
pfree(sp);
ReleaseSysCache(nspTup);
/* Create a Java Signature String from the class name
*/
jcn = JNI_callObjectMethod(clazz, Class_getName);
currCtx = MemoryContextSwitchTo(TopMemoryContext);
className = String_createNTS(jcn);
JNI_deleteLocalRef(jcn);
signatureLen = strlen(className) + 2;
classSignature = palloc(signatureLen + 1);
MemoryContextSwitchTo(currCtx);
sp = classSignature;
cp = className;
*sp++ = 'L';
while((c = *cp++) != 0)
{
if(c == '.')
c = '/';
*sp++ = c;
}
*sp++ = ';';
*sp = 0;
udtClass = TypeClass_alloc2("type.UDT", sizeof(struct TypeClass_), sizeof(struct UDT_));
udtClass->JNISignature = classSignature;
udtClass->javaTypeName = className;
udtClass->javaClass = JNI_newGlobalRef(clazz);
udtClass->canReplaceType = _Type_canReplaceType;
udtClass->coerceDatum = _UDT_coerceDatum;
udtClass->coerceObject = _UDT_coerceObject;
udt = (UDT)TypeClass_allocInstance2(udtClass, typeId, pgType);
udt->sqlTypeName = JNI_newGlobalRef(sqlTypeName);
JNI_deleteLocalRef(sqlTypeName);
udt->init = PgObject_getJavaMethod(clazz, "<init>", "()V");
if(isJavaBasedScalar)
{
/* A scalar mapping that is implemented in Java will have the static method:
*
* T parse(String stringRep, String sqlTypeName);
*
* and a matching:
*
* String toString();
*
* instance method. A pure mapping (i.e. no Java I/O methods) will not have
* this.
*/
udt->toString = PgObject_getJavaMethod(clazz, "toString", "()Ljava/lang/String;");
/* The parse method is a static method on the class with the signature
* (Ljava/lang/String;Ljava/lang/String;)<classSignature>
*/
sp = palloc(signatureLen + 40);
strcpy(sp, "(Ljava/lang/String;Ljava/lang/String;)");
strcpy(sp + 38, classSignature);
udt->parse = PgObject_getStaticJavaMethod(clazz, "parse", sp);
pfree(sp);
}
else
{
udt->toString = 0;
udt->parse = 0;
}
udt->tupleDesc = td;
udt->readSQL = PgObject_getJavaMethod(clazz, "readSQL", "(Ljava/sql/SQLInput;Ljava/lang/String;)V");
udt->writeSQL = PgObject_getJavaMethod(clazz, "writeSQL", "(Ljava/sql/SQLOutput;)V");
Type_registerType(className, (Type)udt);
return udt;
}
static void String_initialize_codec()
{
jmethodID string_intern = PgObject_getJavaMethod(s_String_class,
"intern", "()Ljava/lang/String;");
jstring empty = JNI_newStringUTF( "");
jclass scharset_class =
PgObject_getJavaClass("java/nio/charset/StandardCharsets");
jfieldID scharset_UTF_8 = PgObject_getStaticJavaField(scharset_class,
"UTF_8", "Ljava/nio/charset/Charset;");
jobject u8cs = JNI_getStaticObjectField(scharset_class, scharset_UTF_8);
jclass charset_class = JNI_getObjectClass(u8cs);
jmethodID charset_newDecoder = PgObject_getJavaMethod(charset_class,
"newDecoder", "()Ljava/nio/charset/CharsetDecoder;");
jmethodID charset_newEncoder = PgObject_getJavaMethod(charset_class,
"newEncoder", "()Ljava/nio/charset/CharsetEncoder;");
jclass decoder_class =
PgObject_getJavaClass("java/nio/charset/CharsetDecoder");
jclass encoder_class =
PgObject_getJavaClass("java/nio/charset/CharsetEncoder");
jmethodID encoder_abpc =
PgObject_getJavaMethod(encoder_class, "averageBytesPerChar", "()F");
jclass result_class = PgObject_getJavaClass("java/nio/charset/CoderResult");
jfieldID overflow = PgObject_getStaticJavaField(result_class, "OVERFLOW",
"Ljava/nio/charset/CoderResult;");
jfieldID underflow = PgObject_getStaticJavaField(result_class, "UNDERFLOW",
"Ljava/nio/charset/CoderResult;");
jclass buffer_class = PgObject_getJavaClass("java/nio/Buffer");
s_CharsetDecoder_instance =
JNI_newGlobalRef(JNI_callObjectMethod(u8cs, charset_newDecoder));
s_CharsetEncoder_instance =
JNI_newGlobalRef(JNI_callObjectMethod(u8cs, charset_newEncoder));
s_CharsetDecoder_decode = PgObject_getJavaMethod(decoder_class, "decode",
"(Ljava/nio/ByteBuffer;)Ljava/nio/CharBuffer;");
s_CharsetEncoder_encode = PgObject_getJavaMethod(encoder_class, "encode",
"(Ljava/nio/CharBuffer;Ljava/nio/ByteBuffer;Z)"
"Ljava/nio/charset/CoderResult;");
s_CharsetEncoder_averageBytesPerChar =
JNI_callFloatMethod(s_CharsetEncoder_instance, encoder_abpc);
s_CoderResult_OVERFLOW = JNI_newGlobalRef(
JNI_getStaticObjectField(result_class, overflow));
s_CoderResult_UNDERFLOW = JNI_newGlobalRef(
JNI_getStaticObjectField(result_class, underflow));
s_CoderResult_throwException = PgObject_getJavaMethod(result_class,
"throwException", "()V");
s_CharBuffer_class = (jclass)JNI_newGlobalRef(
PgObject_getJavaClass("java/nio/CharBuffer"));
s_CharBuffer_wrap = PgObject_getStaticJavaMethod(s_CharBuffer_class,
"wrap", "(Ljava/lang/CharSequence;)Ljava/nio/CharBuffer;");
s_Buffer_position = PgObject_getJavaMethod(buffer_class,
"position", "()I");
s_Buffer_remaining = PgObject_getJavaMethod(buffer_class,
"remaining", "()I");
s_the_empty_string = JNI_newGlobalRef(
JNI_callObjectMethod(empty, string_intern));
s_server_encoding = GetDatabaseEncoding();
s_two_step_conversion = PG_UTF8 != s_server_encoding;
uninitialized = false;
}
