MyFirstUDRKit/src/MyFirstUDRKit.cpp

/*
 *  The contents of this file are subject to the Initial
 *  Developer's Public License Version 1.0 (the "License");
 *  you may not use this file except in compliance with the
 *  License. You may obtain a copy of the License at
 *  http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
 *
 *  Software distributed under the License is distributed AS IS,
 *  WITHOUT WARRANTY OF ANY KIND, either express or implied.
 *  See the License for the specific language governing rights
 *  and limitations under the License.
 *
 *  The Original Code was created by Adriano dos Santos Fernandes
 *  for the Firebird Open Source RDBMS project.
 *
 *  Copyright (c) 2008 Adriano dos Santos Fernandes <adrianosf@gmail.com>
 *  and all contributors signed below.
 *
 *  All Rights Reserved.
 *  Contributor(s): ______________________________________.
 *
 *	Paul Reeves, 2023
 *
 */



#include "MyFirstUDRKit.h"

#include <ibase.h>
#include <firebird/UdrCppEngine.h>
#include <firebird/Message.h>

#include "UdrCppTemplates.h"

#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <vector>
#include <memory>

#ifdef HAVE_MATH_H
#include <math.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <ctime>
# endif
#endif

#ifdef HAVE_SYS_TIMEB_H
# include <sys/timeb.h>
#endif

#ifdef HAVE_LOCALE_H
#include <locale.h>
#endif

#include <limits>

#ifdef _WIN32
#include <windows.h>
#define SYSERROR()  GetLastError()
#else
#include <cerrno>
#define SYSERROR()  errno
#endif

using namespace Firebird;


// First, let's start with a function from the UdfBackwardCompatibility
// library and add some additional comments.
// We will also use self-docmenting variable names
// //////////////////////////////////////////////////

/***
 * create function div (
 *    anumerator bigint,
 *    adenominator bigint
 * ) returns bigint
 *    external name 'MyFirstUDRKit!MFK_div!Divide anumerator by adenominator'
 *    engine udr;
 ***/
FB_UDR_BEGIN_FUNCTION(MFK_div)

// Divide integer anumerator 1 by integer adenominator using the stdlib
// Note this differs from the example that shifts with firebird as it returns
// a bigint, not a double precision
//BEGIN
FB_UDR_MESSAGE(InMessage,
							 (FB_BIGINT, anumerator)
							 (FB_BIGINT, adenominator)
);

FB_UDR_MESSAGE(OutMessage,
							 (FB_BIGINT, result)
);

FB_UDR_EXECUTE_FUNCTION
{
	if (in->anumeratorNull || in->adenominatorNull)
	{
		out->resultNull = FB_TRUE;
		out->result = 0;
	}
	else
	{
		out->resultNull = FB_FALSE;
		if (in->adenominator) {
			out->result = std::div(in->anumerator, in->adenominator).quot;
		}
		else
		{
			out->result = int( std::numeric_limits<double>::infinity() );
			ISC_STATUS_ARRAY StatusVector = {isc_arg_gds, isc_arith_except,
				isc_arg_gds, isc_exception_integer_divide_by_zero, isc_arg_end};
				FbException::check(isc_exception_integer_divide_by_zero, status, StatusVector);
		}
	}
}
FB_UDR_END_FUNCTION
//END



/*** DDL
create function flagged (
    flags integer,
    flag integer
) returns integer
    external name 'MyFirstUDRKit!MFK_flagged!Check if flag is set in flags. flag is zero-based.'
    engine udr;

***/
FB_UDR_BEGIN_FUNCTION (MFK_flagged)
//BEGIN
FB_UDR_MESSAGE(InMessage,
		(FB_INTEGER, flags)
		(FB_INTEGER, flag)
	);

	FB_UDR_MESSAGE(OutMessage,
		(FB_INTEGER, result)
	);

	FB_UDR_EXECUTE_FUNCTION
	{
		if ( in->flagsNull != 0 ) {
			out->resultNull = FB_TRUE;
			out->result = 0;
		}
		else
		{
			out->resultNull = FB_FALSE;
			ISC_UINT64 i = ( 1ULL << in->flag );
			out->result = ( in->flags & i ) ? 1 : 0;
		}
	}
FB_UDR_END_FUNCTION
//END

/*** DDL
 * create or alter function LoadBlobFromFile (
 *	afilename varchar(8191),
 *	ablob BLOB
 *	) returns bigint
 *	external name 'MyFirstUDRKit!MFKLoadBlobFromFile!Load file and save to Blob'
 *	engine udr;
 ***/
// NOTE This function would be better as a procedure as that would allow it
// to return the bytes written to the blob.
FB_UDR_BEGIN_FUNCTION (MFK_LoadBlobFromFile)
//BEGIN
FB_UDR_MESSAGE(InMessage,
							 (FB_VARCHAR(8191), afilename)
);

FB_UDR_MESSAGE(OutMessage,
							 (FB_BLOB, ablob)
);


AutoRelease<IAttachment> att;
AutoRelease<ITransaction> tra;
ISC_STATUS_ARRAY statusVector = {0};

FB_UDR_EXECUTE_FUNCTION
{
	// Test Input
	if (in->afilenameNull != 0)  {
		out->ablobNull = FB_TRUE;
		return;
	}


	std::ifstream FileReader;
	FileReader.open( in->afilename.str , std::ifstream::binary | std::ifstream::in );
	if (! FileReader.is_open()) {
//	if (! FileReader.good()) {
		out->ablobNull = FB_TRUE;
		return;
	}



	try {

		att.reset(context->getAttachment(status));
		tra.reset(context->getTransaction(status));
		AutoRelease<IBlob> blob(att->createBlob(status, tra, &out->ablob, 0, nullptr));
		if (blob == nullptr) {
			out->ablobNull = FB_TRUE;
			return;
		}

		std::vector<std::uint8_t> Buffer (MaxSegmentSize, 0);
		std::streamsize DataSize;

		while  ( FileReader.good() ) {
			FileReader.read( (char *)Buffer.data(), Buffer.size() );
			DataSize = FileReader.gcount();
			blob->putSegment( status, DataSize, Buffer.data() );
			// Perhaps test for badbit here?
		}
		if (FileReader.bad()) { // Something went wrong
			// What to do?
			out->ablobNull = FB_TRUE;
			// What do we do with the partially written blob? Is cancel enough?
			blob->cancel( status );
		}
		// ****** IT IS VITAL TO SET THIS IF WRITING TO BLOB WAS SUCCESSFUL ******* //
		out->ablobNull = FB_FALSE;

		blob->close( status );
		blob->release();
		Buffer.clear();
		FileReader.close();
	}
	catch ( const FbException& error )
	{
		throw Firebird::FbException(status, statusVector);
	}
	catch (...) {
		throw std::runtime_error("Error writing file to BLOB.");
	}

}


FB_UDR_END_FUNCTION
//END



/***
create or alter function SaveBlobToFile (
	afilename varchar(8191),
	ablob BLOB
) returns bigint
external name 'MyFirstUDRKit!MFK_SaveBlobToFile!Save blob to file'
engine udr;
***/

FB_UDR_BEGIN_FUNCTION(MFK_SaveBlobToFile)
//BEGIN
FB_UDR_MESSAGE(InMessage,
							 (FB_VARCHAR(8191), afilename)
							 (FB_BLOB, ablob)
);

FB_UDR_MESSAGE(OutMessage,
							 (FB_BIGINT, result)
);

AutoRelease<IAttachment> att;
AutoRelease<ITransaction> tra;
AutoRelease<IBlob> blob;
ISC_STATUS_ARRAY statusVector = {0};


FB_UDR_EXECUTE_FUNCTION
{
	// Test Input
	if (in->afilenameNull != 0 || in->ablobNull != 0 )  {
		out->resultNull = FB_TRUE;
		out->result = 0;
	}

	/*
	 * DOC NOTE - We do not test for existence of the file here!
	 * This should be done prior to calling this function.
	 */

	std::ofstream FileWriter ( in->afilename.str , std::ofstream::binary | std::ofstream::out );
	if (! FileWriter.is_open()) {
//	if (! FileWriter.good()) {
		out->resultNull = FB_TRUE;

		// Convert system error to a negative value and assign to result
		out->result = ( SYSERROR() * -1 );

		// important to set out->resultNull to false here otherwise the error
		// code willbe hidden and NULL returned to the firebird engine. This
		// is because the test for out->resultNull has precedence.
		if ( out->result < 0 ) {
			out->resultNull = FB_FALSE;
		}

		return;
 	}

// This might be useful but doesn't work because it requires libc++ and we compile with libstdc++ on linux
//		else {
// 			    std::filesystem::permissions ( in->afilename.str, std::filesystem::perms::owner_all | std::filesystem::perms::group_all,
// 																				 std::filesystem::perm_options::add );
// 	}


	att.reset(context->getAttachment(status));
	tra.reset(context->getTransaction(status));
	blob.reset(att->openBlob(status, tra, &in->ablob, 0, nullptr));
	try {

		if (blob == nullptr) {
			out->resultNull = FB_TRUE;
			out->result = -1;
			return;
		}

		std::vector<std::uint8_t> Buffer (MaxSegmentSize, 0);
		unsigned BytesRead = 0;
		unsigned BufferSize = 0;

		for (bool Eof = false; !Eof; )
		{
			switch ( blob->getSegment ( status, MaxSegmentSize, Buffer.data(), &BytesRead))
			{
				case IStatus::RESULT_OK:
				case IStatus::RESULT_SEGMENT:
				{
					BufferSize = Buffer.size();
					if ( BufferSize < BytesRead) {
						BytesRead = BufferSize;
					}
					if ( BytesRead < MaxSegmentSize) {
						Buffer.resize( BytesRead);
					}
					FileWriter.write( (char *) Buffer.data(), Buffer.size() );
					out->result += BytesRead;
					continue;
				}
				default:
				{
					blob->close( status ); // will close interface
					blob->release();
					Eof = true;
					break;
				}
			}
		}
		// If we have got this far then we have written the blob.
		// out->resultNULL ***must*** be set to false or else the function will return NULL
		out->resultNull = FB_FALSE;
		Buffer.clear();
		FileWriter.close();
	}
	catch ( const FbException& error )
	{
		throw Firebird::FbException(status, statusVector);
	}
	catch (...) {
		throw std::runtime_error("Error writing BLOB to file.");
	}

}


FB_UDR_END_FUNCTION
//END

/*** DDL
 create function BillDate (
	 d    integer,
	 date
	 ) returns date
	 external name 'my_first_udr_kit!MFK_BillDate!What does BillDate do?'
	 engine udr;
	 ***/
/*
FB_UDR_BEGIN_FUNCTION(MFK_BillDate)

FB_UDR_MESSAGE(InMessage,
	(FB_INTEGER, d)
	(FB_INTEGER, date)
);
FB_UDR_MESSAGE(OutMessage,
	(FB_DATE, result)
	);


FB_UDR_END_FUNCTION
*/