void Double_initialize(void) { Type t_double; Type t_Double; TypeClass cls; s_Double_class = JNI_newGlobalRef(PgObject_getJavaClass("java/lang/Double")); s_DoubleArray_class = JNI_newGlobalRef(PgObject_getJavaClass("[Ljava/lang/Double;")); s_Double_init = PgObject_getJavaMethod(s_Double_class, "<init>", "(D)V"); s_Double_doubleValue = PgObject_getJavaMethod(s_Double_class, "doubleValue", "()D"); cls = TypeClass_alloc("type.Double"); cls->canReplaceType = _Double_canReplace; cls->JNISignature = "Ljava/lang/Double;"; cls->javaTypeName = "java.lang.Double"; cls->coerceDatum = _Double_coerceDatum; cls->coerceObject = _Double_coerceObject; t_Double = TypeClass_allocInstance(cls, FLOAT8OID); cls = TypeClass_alloc("type.double"); cls->JNISignature = "D"; cls->javaTypeName = "double"; cls->invoke = _double_invoke; cls->coerceDatum = _double_coerceDatum; cls->coerceObject = _Double_coerceObject; cls->createArrayType = _double_createArrayType; s_doubleClass = cls; t_double = TypeClass_allocInstance(cls, FLOAT8OID); t_double->objectType = t_Double; Type_registerType("double", t_double); Type_registerType("java.lang.Double", t_Double); }
void Timestamp_initialize(void) { TypeClass cls; s_Timestamp_class = JNI_newGlobalRef(PgObject_getJavaClass("java/sql/Timestamp")); s_Timestamp_init = PgObject_getJavaMethod(s_Timestamp_class, "<init>", "(J)V"); s_Timestamp_getNanos = PgObject_getJavaMethod(s_Timestamp_class, "getNanos", "()I"); s_Timestamp_getTime = PgObject_getJavaMethod(s_Timestamp_class, "getTime", "()J"); s_Timestamp_setNanos = PgObject_getJavaMethod(s_Timestamp_class, "setNanos", "(I)V"); cls = TypeClass_alloc("type.Timestamp"); cls->JNISignature = "Ljava/sql/Timestamp;"; cls->javaTypeName = "java.sql.Timestamp"; cls->canReplaceType = _Timestamp_canReplaceType; cls->coerceDatum = _Timestamp_coerceDatum; cls->coerceObject = _Timestamp_coerceObject; Type_registerType(0, TypeClass_allocInstance(cls, TIMESTAMPOID)); s_TimestampClass = cls; cls = TypeClass_alloc("type.Timestamptz"); cls->JNISignature = "Ljava/sql/Timestamp;"; cls->javaTypeName = "java.sql.Timestamp"; cls->canReplaceType = _Timestamptz_canReplaceType; cls->coerceDatum = _Timestamptz_coerceDatum; cls->coerceObject = _Timestamptz_coerceObject; Type_registerType("java.sql.Timestamp", TypeClass_allocInstance(cls, TIMESTAMPTZOID)); s_TimestamptzClass = cls; }
void Integer_initialize(void) { Type t_int; Type t_Integer; TypeClass cls; s_Integer_class = JNI_newGlobalRef(PgObject_getJavaClass("java/lang/Integer")); s_Integer_init = PgObject_getJavaMethod(s_Integer_class, "<init>", "(I)V"); s_Integer_intValue = PgObject_getJavaMethod(s_Integer_class, "intValue", "()I"); cls = TypeClass_alloc("type.Integer"); cls->canReplaceType = _Integer_canReplace; cls->JNISignature = "Ljava/lang/Integer;"; cls->javaTypeName = "java.lang.Integer"; cls->coerceDatum = _Integer_coerceDatum; cls->coerceObject = _Integer_coerceObject; t_Integer = TypeClass_allocInstance(cls, INT4OID); cls = TypeClass_alloc("type.int"); cls->JNISignature = "I"; cls->javaTypeName = "int"; cls->invoke = _int_invoke; cls->coerceDatum = _int_coerceDatum; cls->coerceObject = _Integer_coerceObject; cls->createArrayType = _int_createArrayType; s_intClass = cls; t_int = TypeClass_allocInstance(cls, INT4OID); t_int->objectType = t_Integer; Type_registerType("int", t_int); Type_registerType("java.lang.Integer", t_Integer); }
void Boolean_initialize(void) { Type t_boolean; Type t_Boolean; TypeClass cls; s_Boolean_class = JNI_newGlobalRef(PgObject_getJavaClass("java/lang/Boolean")); s_Boolean_init = PgObject_getJavaMethod(s_Boolean_class, "<init>", "(Z)V"); s_Boolean_booleanValue = PgObject_getJavaMethod(s_Boolean_class, "booleanValue", "()Z"); cls = TypeClass_alloc("type.Boolean"); cls->canReplaceType = _Boolean_canReplace; cls->JNISignature = "Ljava/lang/Boolean;"; cls->javaTypeName = "java.lang.Boolean"; cls->coerceDatum = _Boolean_coerceDatum; cls->coerceObject = _Boolean_coerceObject; t_Boolean = TypeClass_allocInstance(cls, BOOLOID); cls = TypeClass_alloc("type.boolean"); cls->JNISignature = "Z"; cls->javaTypeName = "boolean"; cls->invoke = _boolean_invoke; cls->coerceDatum = _boolean_coerceDatum; cls->coerceObject = _Boolean_coerceObject; cls->createArrayType = _boolean_createArrayType; s_booleanClass = cls; t_boolean = TypeClass_allocInstance(cls, BOOLOID); t_boolean->objectType = t_Boolean; Type_registerType("boolean", t_boolean); Type_registerType("java.lang.Boolean", t_Boolean); }
void byte_array_initialize(void) { TypeClass cls = TypeClass_alloc("type.byte[]"); cls->JNISignature = "[B"; cls->javaTypeName = "byte[]"; cls->coerceDatum = _byte_array_coerceDatum; cls->coerceObject = _byte_array_coerceObject; Type_registerType("byte[]", TypeClass_allocInstance(cls, BYTEAOID)); s_byteArray_class = JNI_newGlobalRef(PgObject_getJavaClass("[B")); s_BlobValue_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/jdbc/BlobValue")); s_BlobValue_length = PgObject_getJavaMethod(s_BlobValue_class, "length", "()J"); s_BlobValue_getContents = PgObject_getJavaMethod(s_BlobValue_class, "getContents", "(Ljava/nio/ByteBuffer;)V"); }
void Type_initialize(void) { s_typeByOid = HashMap_create(59, TopMemoryContext); s_obtainerByOid = HashMap_create(59, TopMemoryContext); s_obtainerByJavaName = HashMap_create(59, TopMemoryContext); String_initialize(); Any_initialize(); Coerce_initialize(); Void_initialize(); Boolean_initialize(); Byte_initialize(); Short_initialize(); Integer_initialize(); Long_initialize(); Float_initialize(); Double_initialize(); BigDecimal_initialize(); Date_initialize(); Time_initialize(); Timestamp_initialize(); Oid_initialize(); AclId_initialize(); ErrorData_initialize(); LargeObject_initialize(); byte_array_initialize(); JavaWrapper_initialize(); ExecutionPlan_initialize(); Portal_initialize(); TriggerData_initialize(); Relation_initialize(); TupleDesc_initialize(); Tuple_initialize(); TupleTable_initialize(); Composite_initialize(); s_Map_class = JNI_newGlobalRef(PgObject_getJavaClass("java/util/Map")); s_Map_get = PgObject_getJavaMethod(s_Map_class, "get", "(Ljava/lang/Object;)Ljava/lang/Object;"); s_Iterator_class = JNI_newGlobalRef(PgObject_getJavaClass("java/util/Iterator")); s_Iterator_hasNext = PgObject_getJavaMethod(s_Iterator_class, "hasNext", "()Z"); s_Iterator_next = PgObject_getJavaMethod(s_Iterator_class, "next", "()Ljava/lang/Object;"); }
void TupleTable_initialize(void) { s_TupleTable_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/TupleTable")); s_TupleTable_init = PgObject_getJavaMethod( s_TupleTable_class, "<init>", "(Lorg/postgresql/pljava/internal/TupleDesc;[Lorg/postgresql/pljava/internal/Tuple;)V"); }
void Invocation_initialize(void) { jclass cls; JNINativeMethod invocationMethods[] = { { "_getCurrent", "()Lorg/postgresql/pljava/jdbc/Invocation;", Java_org_postgresql_pljava_jdbc_Invocation__1getCurrent }, { "_getNestingLevel", "()I", Java_org_postgresql_pljava_jdbc_Invocation__1getNestingLevel }, { "_clearErrorCondition", "()V", Java_org_postgresql_pljava_jdbc_Invocation__1clearErrorCondition }, { "_register", "()V", Java_org_postgresql_pljava_jdbc_Invocation__1register }, { 0, 0, 0 } }; cls = PgObject_getJavaClass("org/postgresql/pljava/jdbc/Invocation"); PgObject_registerNatives2(cls, invocationMethods); s_Invocation_onExit = PgObject_getJavaMethod(cls, "onExit", "()V"); JNI_deleteLocalRef(cls); }
void Tuple_initialize(void) { TypeClass cls; JNINativeMethod methods[] = { { "_getObject", "(JJILjava/lang/Class;)Ljava/lang/Object;", Java_org_postgresql_pljava_internal_Tuple__1getObject }, { "_free", "(J)V", Java_org_postgresql_pljava_internal_Tuple__1free }, { 0, 0, 0 }}; s_Tuple_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/Tuple")); PgObject_registerNatives2(s_Tuple_class, methods); s_Tuple_init = PgObject_getJavaMethod(s_Tuple_class, "<init>", "(J)V"); cls = JavaWrapperClass_alloc("type.Tuple"); cls->JNISignature = "Lorg/postgresql/pljava/internal/Tuple;"; cls->javaTypeName = "org.postgresql.pljava.internal.Tuple"; cls->coerceDatum = _Tuple_coerceDatum; Type_registerType("org.postgresql.pljava.internal.Tuple", TypeClass_allocInstance(cls, InvalidOid)); }
void String_initialize(void) { s_Object_class = (jclass)JNI_newGlobalRef(PgObject_getJavaClass("java/lang/Object")); s_Object_toString = PgObject_getJavaMethod(s_Object_class, "toString", "()Ljava/lang/String;"); s_String_class = (jclass)JNI_newGlobalRef(PgObject_getJavaClass("java/lang/String")); s_StringClass = TypeClass_alloc2("type.String", sizeof(struct TypeClass_), sizeof(struct String_)); s_StringClass->JNISignature = "Ljava/lang/String;"; s_StringClass->javaTypeName = "java.lang.String"; s_StringClass->canReplaceType = _String_canReplaceType; s_StringClass->coerceDatum = _String_coerceDatum; s_StringClass->coerceObject = _String_coerceObject; /* * Frame push/pop hoisted here out of String_initialize_codec to mollify * pre-C99 compilers that don't want that function to have declarations * after a statement. */ JNI_pushLocalFrame(16); String_initialize_codec(); JNI_popLocalFrame(NULL); /* * Registering known types will increase the performance * a bit. The "default" is used when all else fails. */ Type_registerType2(TEXTOID, 0, String_obtain); Type_registerType2(CSTRINGOID, 0, String_obtain); Type_registerType2(BPCHAROID, 0, String_obtain); Type_registerType2(NAMEOID, 0, String_obtain); Type_registerType2(VARCHAROID, "java.lang.String", String_obtain); }
void SQLInputFromChunk_initialize(void) { JNINativeMethod methods[] = { { "_readByte", "(JI)I", Java_org_postgresql_pljava_jdbc_SQLInputFromChunk__1readByte }, { "_readBytes", "(JI[BI)V", Java_org_postgresql_pljava_jdbc_SQLInputFromChunk__1readBytes }, { 0, 0, 0 }}; s_SQLInputFromChunk_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/jdbc/SQLInputFromChunk")); PgObject_registerNatives2(s_SQLInputFromChunk_class, methods); s_SQLInputFromChunk_init = PgObject_getJavaMethod(s_SQLInputFromChunk_class, "<init>", "(JI)V"); s_SQLInputFromChunk_close = PgObject_getJavaMethod(s_SQLInputFromChunk_class, "close", "()V"); }
void Function_initialize(void) { s_funcMap = HashMap_create(59, TopMemoryContext); s_Loader_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/sqlj/Loader")); s_Loader_getSchemaLoader = PgObject_getStaticJavaMethod(s_Loader_class, "getSchemaLoader", "(Ljava/lang/String;)Ljava/lang/ClassLoader;"); s_Loader_getTypeMap = PgObject_getStaticJavaMethod(s_Loader_class, "getTypeMap", "(Ljava/lang/String;)Ljava/util/Map;"); s_ClassLoader_class = JNI_newGlobalRef(PgObject_getJavaClass("java/lang/ClassLoader")); s_ClassLoader_loadClass = PgObject_getJavaMethod(s_ClassLoader_class, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;"); s_FunctionClass = PgObjectClass_create("Function", sizeof(struct Function_), _Function_finalize); }
void TupleDesc_initialize(void) { TypeClass cls; JNINativeMethod methods[] = { { "_getColumnName", "(JI)Ljava/lang/String;", Java_org_postgresql_pljava_internal_TupleDesc__1getColumnName }, { "_getColumnIndex", "(JLjava/lang/String;)I", Java_org_postgresql_pljava_internal_TupleDesc__1getColumnIndex }, { "_formTuple", "(J[Ljava/lang/Object;)Lorg/postgresql/pljava/internal/Tuple;", Java_org_postgresql_pljava_internal_TupleDesc__1formTuple }, { "_getOid", "(JI)Lorg/postgresql/pljava/internal/Oid;", Java_org_postgresql_pljava_internal_TupleDesc__1getOid }, { "_free", "(J)V", Java_org_postgresql_pljava_internal_TupleDesc__1free }, { 0, 0, 0 }}; s_TupleDesc_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/TupleDesc")); PgObject_registerNatives2(s_TupleDesc_class, methods); s_TupleDesc_init = PgObject_getJavaMethod(s_TupleDesc_class, "<init>", "(JI)V"); cls = JavaWrapperClass_alloc("type.TupleDesc"); cls->JNISignature = "Lorg/postgresql/pljava/internal/TupleDesc;"; cls->javaTypeName = "org.postgresql.pljava.internal.TupleDesc"; cls->coerceDatum = _TupleDesc_coerceDatum; Type_registerType("org.postgresql.pljava.internal.TupleDesc", TypeClass_allocInstance(cls, InvalidOid)); }
void AclId_initialize(void) { JNINativeMethod methods[] = { { "_getUser", "()Lorg/postgresql/pljava/internal/AclId;", Java_org_postgresql_pljava_internal_AclId__1getUser }, { "_getOuterUser", "()Lorg/postgresql/pljava/internal/AclId;", Java_org_postgresql_pljava_internal_AclId__1getOuterUser }, { "_fromName", "(Ljava/lang/String;)Lorg/postgresql/pljava/internal/AclId;", Java_org_postgresql_pljava_internal_AclId__1fromName }, { "_getName", "()Ljava/lang/String;", Java_org_postgresql_pljava_internal_AclId__1getName }, { "_hasSchemaCreatePermission", "(Lorg/postgresql/pljava/internal/Oid;)Z", Java_org_postgresql_pljava_internal_AclId__1hasSchemaCreatePermission }, { "_isSuperuser", "()Z", Java_org_postgresql_pljava_internal_AclId__1isSuperuser }, { 0, 0, 0 }}; s_AclId_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/AclId")); PgObject_registerNatives2(s_AclId_class, methods); s_AclId_init = PgObject_getJavaMethod(s_AclId_class, "<init>", "(I)V"); s_AclId_m_native = PgObject_getJavaField(s_AclId_class, "m_native", "I"); }
void String_initialize(void) { s_Object_class = (jclass)JNI_newGlobalRef(PgObject_getJavaClass("java/lang/Object")); s_Object_toString = PgObject_getJavaMethod(s_Object_class, "toString", "()Ljava/lang/String;"); s_String_class = (jclass)JNI_newGlobalRef(PgObject_getJavaClass("java/lang/String")); s_StringClass = TypeClass_alloc2("type.String", sizeof(struct TypeClass_), sizeof(struct String_)); s_StringClass->JNISignature = "Ljava/lang/String;"; s_StringClass->javaTypeName = "java.lang.String"; s_StringClass->canReplaceType = _String_canReplaceType; s_StringClass->coerceDatum = _String_coerceDatum; s_StringClass->coerceObject = _String_coerceObject; /* * Registering known types will increase the performance * a bit. The "default" is used when all else fails. */ Type_registerType2(TEXTOID, 0, String_obtain); Type_registerType2(CSTRINGOID, 0, String_obtain); Type_registerType2(BPCHAROID, 0, String_obtain); Type_registerType2(NAMEOID, 0, String_obtain); Type_registerType2(VARCHAROID, "java.lang.String", String_obtain); }
void Relation_initialize(void) { JNINativeMethod methods[] = { { "_free", "(J)V", Java_org_postgresql_pljava_internal_Relation__1free }, { "_getName", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_Relation__1getName }, { "_getSchema", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_Relation__1getSchema }, { "_getTupleDesc", "(J)Lorg/postgresql/pljava/internal/TupleDesc;", Java_org_postgresql_pljava_internal_Relation__1getTupleDesc }, { "_modifyTuple", "(JJ[I[Ljava/lang/Object;)Lorg/postgresql/pljava/internal/Tuple;", Java_org_postgresql_pljava_internal_Relation__1modifyTuple }, { 0, 0, 0 } }; s_Relation_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/Relation")); PgObject_registerNatives2(s_Relation_class, methods); s_Relation_init = PgObject_getJavaMethod(s_Relation_class, "<init>", "(J)V"); }
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; }
void LargeObject_initialize(void) { TypeClass cls; JNINativeMethod methods[] = { { "_create", "(I)Lorg/postgresql/pljava/internal/Oid;", Java_org_postgresql_pljava_internal_LargeObject__1create }, { "_drop", "(Lorg/postgresql/pljava/internal/Oid;)I", Java_org_postgresql_pljava_internal_LargeObject__1drop }, { "_open", "(Lorg/postgresql/pljava/internal/Oid;I)Lorg/postgresql/pljava/internal/LargeObject;", Java_org_postgresql_pljava_internal_LargeObject__1open }, { "_close", "(J)V", Java_org_postgresql_pljava_internal_LargeObject__1close }, { "_getId", "(J)Lorg/postgresql/pljava/internal/Oid;", Java_org_postgresql_pljava_internal_LargeObject__1getId }, { "_length", "(J)J", Java_org_postgresql_pljava_internal_LargeObject__1length }, { "_seek", "(JJI)J", Java_org_postgresql_pljava_internal_LargeObject__1seek }, { "_tell", "(J)J", Java_org_postgresql_pljava_internal_LargeObject__1tell }, { "_truncate", "(JJ)V", Java_org_postgresql_pljava_internal_LargeObject__1truncate }, { "_read", "(J[B)I", Java_org_postgresql_pljava_internal_LargeObject__1read }, { "_write", "(J[B)I", Java_org_postgresql_pljava_internal_LargeObject__1write }, { 0, 0, 0 } }; s_LargeObject_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/LargeObject")); PgObject_registerNatives2(s_LargeObject_class, methods); s_LargeObject_init = PgObject_getJavaMethod(s_LargeObject_class, "<init>", "(J)V"); cls = TypeClass_alloc("type.LargeObject"); cls->JNISignature = "Lorg/postgresql/pljava/internal/LargeObject;"; cls->javaTypeName = "org.postgresql.pljava.internal.LargeObject"; Type_registerType("org.postgresql.pljava.internal.LargeObject", TypeClass_allocInstance(cls, InvalidOid)); }
/* 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; }
void TriggerData_initialize(void) { TypeClass cls; JNINativeMethod methods[] = { { "_free", "(J)V", Java_org_postgresql_pljava_internal_TriggerData__1free }, { "_getRelation", "(J)Lorg/postgresql/pljava/internal/Relation;", Java_org_postgresql_pljava_internal_TriggerData__1getRelation }, { "_getTriggerTuple", "(J)Lorg/postgresql/pljava/internal/Tuple;", Java_org_postgresql_pljava_internal_TriggerData__1getTriggerTuple }, { "_getNewTuple", "(J)Lorg/postgresql/pljava/internal/Tuple;", Java_org_postgresql_pljava_internal_TriggerData__1getNewTuple }, { "_getArguments", "(J)[Ljava/lang/String;", Java_org_postgresql_pljava_internal_TriggerData__1getArguments }, { "_getName", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_TriggerData__1getName }, { "_isFiredAfter", "(J)Z", Java_org_postgresql_pljava_internal_TriggerData__1isFiredAfter }, { "_isFiredBefore", "(J)Z", Java_org_postgresql_pljava_internal_TriggerData__1isFiredBefore }, { "_isFiredForEachRow", "(J)Z", Java_org_postgresql_pljava_internal_TriggerData__1isFiredForEachRow }, { "_isFiredForStatement", "(J)Z", Java_org_postgresql_pljava_internal_TriggerData__1isFiredForStatement }, { "_isFiredByDelete", "(J)Z", Java_org_postgresql_pljava_internal_TriggerData__1isFiredByDelete }, { "_isFiredByInsert", "(J)Z", Java_org_postgresql_pljava_internal_TriggerData__1isFiredByInsert }, { "_isFiredByUpdate", "(J)Z", Java_org_postgresql_pljava_internal_TriggerData__1isFiredByUpdate }, { 0, 0, 0 } }; s_TriggerData_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/TriggerData")); PgObject_registerNatives2(s_TriggerData_class, methods); s_TriggerData_init = PgObject_getJavaMethod(s_TriggerData_class, "<init>", "(J)V"); s_TriggerData_getTriggerReturnTuple = PgObject_getJavaMethod(s_TriggerData_class, "getTriggerReturnTuple", "()J"); /* Use interface name for signatures. */ cls = TypeClass_alloc("type.TriggerData"); cls->JNISignature = "Lorg/postgresql/pljava/TriggerData;"; cls->javaTypeName = "org.postgresql.pljava.TriggerData"; Type_registerType("org.postgresql.pljava.TriggerData", TypeClass_allocInstance(cls, InvalidOid)); }
void ErrorData_initialize(void) { JNINativeMethod methods[] = { { "_getErrorLevel", "(J)I", Java_org_postgresql_pljava_internal_ErrorData__1getErrorLevel }, { "_isOutputToServer", "(J)Z", Java_org_postgresql_pljava_internal_ErrorData__1isOutputToServer }, { "_isOutputToClient", "(J)Z", Java_org_postgresql_pljava_internal_ErrorData__1isOutputToClient }, { "_isShowFuncname", "(J)Z", Java_org_postgresql_pljava_internal_ErrorData__1isShowFuncname }, { "_getFilename", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getFilename }, { "_getLineno", "(J)I", Java_org_postgresql_pljava_internal_ErrorData__1getLineno }, { "_getFuncname", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getFuncname }, { "_getSqlState", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getSqlState }, { "_getMessage", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getMessage }, { "_getDetail", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getDetail }, { "_getHint", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getHint }, { "_getContextMessage", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getContextMessage }, { "_getCursorPos", "(J)I", Java_org_postgresql_pljava_internal_ErrorData__1getCursorPos }, { "_getInternalPos", "(J)I", Java_org_postgresql_pljava_internal_ErrorData__1getInternalPos }, { "_getInternalQuery", "(J)Ljava/lang/String;", Java_org_postgresql_pljava_internal_ErrorData__1getInternalQuery }, { "_getSavedErrno", "(J)I", Java_org_postgresql_pljava_internal_ErrorData__1getSavedErrno }, { "_free", "(J)V", Java_org_postgresql_pljava_internal_ErrorData__1free }, { 0, 0, 0 } }; s_ErrorData_class = JNI_newGlobalRef(PgObject_getJavaClass("org/postgresql/pljava/internal/ErrorData")); PgObject_registerNatives2(s_ErrorData_class, methods); s_ErrorData_init = PgObject_getJavaMethod(s_ErrorData_class, "<init>", "(J)V"); s_ErrorData_getNativePointer = PgObject_getJavaMethod(s_ErrorData_class, "getNativePointer", "()J"); }