sypodlobjects.cpp

使用OLE DB进行数据库编程

		_tcscat(msg, _T("\nNo such interface supported"));
		break;
	}


} 

//********************************************************************************
/////////////////////  GENERIC FUNCTIONS ////////////////////////////////
//********************************************************************************

DATE DateFromDBTS(DBTIMESTAMP dbts)
{
	DATE dtDest;

	int anMonthDayInYear[13] = {0, 31, 59, 90, 120, 151, 181, 
                                       212, 243, 273, 304, 334, 365};

	// Validate year and month (ignore day of week and milliseconds)
	if (dbts.year > 9999 || dbts.month < 1 || dbts.month > 12)
		return NULL;

	//  Check for leap year and set the number of days in the month
	BOOL bLeapYear = ((dbts.year & 3) == 0) &&
		((dbts.year % 100) != 0 || (dbts.year % 400) == 0);

	int nDaysInMonth =
		anMonthDayInYear[dbts.month] - anMonthDayInYear[dbts.month-1] +
		((bLeapYear && dbts.day == 29 && dbts.month == 2) ? 1 : 0);

	// Finish validating the date
	if (dbts.day < 1 || dbts.day > nDaysInMonth)
	{
		return NULL;
	}

	if(dbts.hour > 23 || dbts.minute > 59 || dbts.second > 59)
	{
		dbts.hour = 0;
		dbts.minute = 0;
		dbts.second = 0;
	}

	// Cache the date in days and time in fractional days
	long nDate;
	double dblTime;

	//It is a valid date; make Jan 1, 1AD be 1
	nDate = dbts.year * 365L + dbts.year/4 - dbts.year/100 + dbts.year/400 +
		anMonthDayInYear[dbts.month-1] + dbts.day;

	//  If leap year and it's before March, subtract 1:
	if (dbts.month <= 2 && bLeapYear)
		--nDate;

	//  Offset so that 12/30/1899 is 0
	nDate -= 693959L;

	dblTime = (((long)dbts.hour * 3600L) +  // hrs in seconds
		((long)dbts.minute * 60L) +  // mins in seconds
 		((long)dbts.second)) / 86400.;

	dtDest = (double) nDate + ((nDate >= 0) ? dblTime : -dblTime);

	return dtDest;
}

//*******************************************************************************

DBTIMESTAMP DBTSFromDate(DATE dtSrc)
{
	DBTIMESTAMP dbts;

	int anMonthDayInYear[13] = {0, 31, 59, 90, 120, 151, 181, 
                                       212, 243, 273, 304, 334, 365};
	
	memset(&dbts, 0, sizeof(DBTIMESTAMP));

	long nDays;             // Number of days since Dec. 30, 1899
	long nDaysAbsolute;     // Number of days since 1/1/0
	long nSecsInDay;        // Time in seconds since midnight
	long nMinutesInDay;     // Minutes in day

	long n400Years;         // Number of 400 year increments since 1/1/0
	long n400Century;       // Century within 400 year block (0,1,2 or 3)
	long n4Years;           // Number of 4 year increments since 1/1/0
	long n4Day;             // Day within 4 year block
							//  (0 is 1/1/yr1, 1460 is 12/31/yr4)
	long n4Yr;              // Year within 4 year block (0,1,2 or 3)
	BOOL bLeap4 = TRUE;     // TRUE if 4 year block includes leap year

	double dblDate = dtSrc; // tempory serial date

	// If a valid date, then this conversion should not overflow
	nDays = (long)dblDate;

	// Round to the second
	dblDate += ((dtSrc > 0.0) ? (1.0/172800.0) : (-1 * (1.0/172800.0)));

	nDaysAbsolute = (long)dblDate + 693959L; // Add days from 1/1/0 to 12/30/1899

	dblDate = fabs(dblDate);
	nSecsInDay = (long)((dblDate - floor(dblDate)) * 86400.);

	// Calculate the day of week (sun=1, mon=2...)
	//   -1 because 1/1/0 is Sat.  +1 because we want 1-based
	//tmDest.tm_wday = (int)((nDaysAbsolute - 1) % 7L) + 1;
	
	// Leap years every 4 yrs except centuries not multiples of 400.
	n400Years = (long)(nDaysAbsolute / 146097L);

	// Set nDaysAbsolute to day within 400-year block
	nDaysAbsolute %= 146097L;

	// -1 because first century has extra day
	n400Century = (long)((nDaysAbsolute - 1) / 36524L);

	// Non-leap century
	if (n400Century != 0)
	{
		// Set nDaysAbsolute to day within century
		nDaysAbsolute = (nDaysAbsolute - 1) % 36524L;

		// +1 because 1st 4 year increment has 1460 days
		n4Years = (long)((nDaysAbsolute + 1) / 1461L);

		if (n4Years != 0)
			n4Day = (long)((nDaysAbsolute + 1) % 1461L);
		else
		{
			bLeap4 = FALSE;
			n4Day = (long)nDaysAbsolute;
		}
	}
	else
	{
		// Leap century - not special case!
		n4Years = (long)(nDaysAbsolute / 1461L);
		n4Day = (long)(nDaysAbsolute % 1461L);
	}

	if (bLeap4)
	{
		// -1 because first year has 366 days
		n4Yr = (n4Day - 1) / 365;

		if (n4Yr != 0)
			n4Day = (n4Day - 1) % 365;
	}
	else
	{
		n4Yr = n4Day / 365;
		n4Day %= 365;
	}

	// n4Day is now 0-based day of year. Save 1-based day of year, year number
	//tmDest.tm_yday = (int)n4Day + 1;
	dbts.year = (short)(n400Years * 400 + n400Century * 100 + n4Years * 4 + n4Yr);

	// Handle leap year: before, on, and after Feb. 29.
	if (n4Yr == 0 && bLeap4)
	{
		// Leap Year
		if (n4Day == 59)
		{
			dbts.month = 2;
			dbts.day = 29;
			goto DoTime;
		}

		// Pretend it's not a leap year for month/day comp.
		if (n4Day >= 60)
			--n4Day;
	}

	// Make n4DaY a 1-based day of non-leap year and compute
	//  month/day for everything but Feb. 29.
	++n4Day;

	// Month number always >= n/32, so save some loop time 
	for (dbts.month = (n4Day >> 5) + 1;
		n4Day > anMonthDayInYear[dbts.month]; dbts.month++);
		
	dbts.day = (int)(n4Day - anMonthDayInYear[dbts.month - 1]);

DoTime:
	if (nSecsInDay == 0)
		dbts.hour = dbts.minute = dbts.second = 0;
	else
	{
		dbts.second = (short)((int)nSecsInDay % 60L);
		nMinutesInDay = nSecsInDay / 60L;
		dbts.minute = (int)nMinutesInDay % 60;
		dbts.hour = (int)nMinutesInDay / 60;
	}

	return dbts;
}

//********************************************************************************

DBDATE DBDateFromDBTS(DBTIMESTAMP dtSrc)
{
	DBDATE mDDRet;

	mDDRet.day = dtSrc.day;
	mDDRet.month = dtSrc.month;
	mDDRet.year = dtSrc.year;

	return mDDRet;
}

//********************************************************************************

DBTIMESTAMP DBTSFromDBDate(DBDATE mDDRet)
{
	DBTIMESTAMP dtSrc;

	memset(&dtSrc, 0, sizeof(DBTIMESTAMP));

	dtSrc.day = mDDRet.day;
	dtSrc.month = mDDRet.month;
	dtSrc.year = mDDRet.year;

	return dtSrc;
}

//********************************************************************************

DBTIME DBTimeFromDBTS(DBTIMESTAMP dtSrc)
{
	DBTIME mDDRet;

	mDDRet.hour = dtSrc.hour;
	mDDRet.minute = dtSrc.minute;
	mDDRet.second = dtSrc.second;

	return mDDRet;
}

//********************************************************************************

DBTIMESTAMP DBTSFromDBTime(DBTIME mDDRet)
{
	DBTIMESTAMP dtSrc;

	memset(&dtSrc, 0, sizeof(DBTIMESTAMP));

	dtSrc.hour = mDDRet.hour;
	dtSrc.minute = mDDRet.minute;
	dtSrc.second = mDDRet.second;

	return dtSrc;
}

//********************************************************************************

LPCTSTR GetDataTypeName(WORD dbtype)
{
	LPCTSTR mStr;

	switch(dbtype)
	{
	case  0:	//DBTYPE_EMPTY = 0,
		mStr = _T("Empty");
		break;
	case 1:		//DBTYPE_NULL = 1,
		mStr = _T("NULL");
		break;
	case 2:		//DBTYPE_I2 = 2,
		mStr = _T("Short");
		break;
	case 3:		//DBTYPE_I4 = 3,
		mStr = _T("Long");
		break;
	case 4:		//DBTYPE_R4 = 4,
		mStr = _T("Float");
		break;
	case 5:		//DBTYPE_R8 = 5,
		mStr = _T("Double");
		break;
	case 6:		//DBTYPE_CY = 6,
		mStr = _T("Currency");
		break;
	case 7:		//DBTYPE_DATE = 7,
		mStr = _T("Date");
		break;
	case 8:		//DBTYPE_BSTR = 8,
		mStr = _T("BSTR");
		break;
	case 9:		//DBTYPE_IDISPATCH = 9,
		mStr = _T("IDispatch Pointer");
		break;
	case 10:	//DBTYPE_ERROR = 10,
		mStr = _T("ErrorCode");
		break;
	case 11:	//DBTYPE_BOOL = 11,
		mStr = _T("Boolean");
		break;
	case 12:	//DBTYPE_VARIANT = 12,
		mStr = _T("Variant");
		break;
	case 13:	//DBTYPE_IUNKNOWN = 13,
		mStr = _T("IUnknown Pointer");
		break;
	case 14:	//DBTYPE_DECIMAL = 14,
		mStr = _T("Decimal");
		break;
	case 17:	//DBTYPE_UI1 = 17,
		mStr = _T("Byte");
		break;
	case 0x2000: //DBTYPE_ARRAY = 0x2000,
		mStr = _T("SafeArray");
		break;
	case 0x4000: //DBTYPE_BYREF = 0x4000,
		mStr = _T("void *");
		break;
	case 16:	//DBTYPE_I1 = 16,
		mStr = _T("Signed Char");
		break;
	case 18:	//DBTYPE_UI2 = 18,
		mStr = _T("USHORT");
		break;
	case 19:	//DBTYPE_UI4 = 19,
		mStr = _T("ULONG");
		break;
	case 20:	//DBTYPE_I8 = 20,
		mStr = _T("LARGE_INTEGER");
		break;
	case 21:	//DBTYPE_UI8 = 21,
		mStr = _T("Unsigned LARGE_INTEGER");
		break;
	case 72:	//DBTYPE_GUID = 72,
		mStr = _T("GUID");
		break;
	case 0x1000: //DBTYPE_VECTOR = 0x1000,
		mStr = _T("DBVECTOR");
		break;
	case 64:	//DBTYPE_FILETIME = 64,
		mStr = _T("FileTime");
		break;
	case 128:	//DBTYPE_BYTES = 128,
		mStr = _T("Byte Array");
		break;
	case 129:	//DBTYPE_STR = 129,
		mStr = _T("CHAR");
		break;
	case 130: //DBTYPE_WSTR = 130,
		mStr = _T("Unicode String");
		break;
	case 131: //DBTYPE_NUMERIC = 131,
		mStr = _T("Numeric");
		break;
	case 132: //DBTYPE_UDT = 132,
		mStr = _T("User-Defined Type");
		break;
	case 133: //DBTYPE_DBDATE = 133,
		mStr = _T("DBDATE");
		break;
	case 134: //DBTYPE_DBTIME = 134,
		mStr = _T("DBTIME");
		break;
	case 135: //DBTYPE_DBTIMESTAMP = 135
		mStr = _T("DBTIMESTAMP");
		break;
	case 136: //DBTYPE_HCHAPTER = 136
		mStr = _T("Chapter");
		break;
	case 138: //DBTYPE_PROPVARIANT = 138,
		mStr = _T("PROPVARIANT");
		break;
	case 139: //DBTYPE_VARNUMERIC = 139
		mStr = _T("VARNUMERIC");
		break;
	default:
		mStr = _T("");
	}

	return mStr; 
}

//********************************************************************************
/////////////////////  CSypODLError Object ////////////////////////////////
//********************************************************************************

CSypODLError::CSypODLError()
{
	mErrMsg = "";
	mErrLoc = "";
	mErrCtx = "";
}

//***********************************************

CSypODLError::~CSypODLError()
{

}

//***********************************************

CString CSypODLError::GetErrorMsg()
{
	return mErrMsg;
}

//***********************************************

CString CSypODLError::GetErrorLoc()
{
	return mErrLoc;
}

//***********************************************

CString CSypODLError::GetErrorCtx()
{
	return mErrCtx;
}

//***********************************************

void CSypODLError::ClearErrors()
{
	mErrMsg = "";
	mErrLoc = "";
	mErrCtx = "";
}

//***********************************************

void CSypODLError::SetError(CString msg, CString loc, CString ctx)
{
	mErrMsg = msg;
	mErrLoc = loc;
	mErrCtx = ctx;
}

//***********************************************