lb_dbase.cpp

在手机操作系统symbina上使用的一个脚本扩展语言的代码实现,可以参考用于自己的开发

		TInt posB=aDatabase.LocateReverse('"');
		lex=aDatabase.Mid(posB+1);
		dbName=aDatabase.Mid(posA+1,posB-posA-1);
		}
	else
		dbName=lex.NextToken();

	aFs.Parse(dbName,parser);

	if (aMode==EDbOpen)
		{
		iParentDbase=iDbCollect.CreateOrOpenDbaseL(parser.FullName(),EDbOpen,allowUpdates); 
		}
	else
		DoCreateL(lex,parser,*aFieldMap);
	}

EXPORT_C COplRowSet* COplRowSet::NewLC(COplDbCollection& aDbCollect, RFs& aFs,const TDesC& aDatabase,COplFieldMap* aFieldMap,TOplDbOpenMode aMode, TBool allowUpdates)
//
// Partial construction when opening, full construction on creation
//
	{
	COplRowSet* self= new (ELeave) COplRowSet(aDbCollect);
	CleanupStack::PushL(self);
	self->ConstructL(aFs,aDatabase,aFieldMap,aMode, allowUpdates);
	return self;
	}

EXPORT_C void COplRowSet::OpenRowSetL(RDbRowSet* aRowSet,TBool aIsATable,COplFieldMap* aFieldMap)
//
// Complete opening of a rowset
//
	{
	iDbRowSet=aRowSet;		// take ownership
	iAmATable=aIsATable;
	iDbColSet=iDbRowSet->ColSetL();
	if (iParentDbase->DataApp())
		ExpandFieldMapToCoverRichText(*aFieldMap);
	TInt oplFields=aFieldMap->GetNoOfFields(); 
	if (oplFields>(iDbColSet->Count()))			// check no extra opl handles
		User::Leave(KOplErrInvalidArgs);
	for (TInt ii=1;ii<=oplFields;ii++)			// check handles are of correct type
		{
		if ((aFieldMap->ReadType(ii-1))!=EDbColBit)
			{
			if ((aFieldMap->ReadType(ii-1))!=((*iDbColSet)[ii].iType))
			User::Leave(KOplErrInvalidArgs);
			}
		}
	}

EXPORT_C COplRowSet* COplRowSet::NewL(COplDbCollection& aDbCollect, RFs& aFs, const TDesC& aString, COplFieldMap* aFieldMap,TOplDbOpenMode aMode, TBool allowUpdates)
	{
	COplRowSet* self=NewLC(aDbCollect,aFs,aString,aFieldMap,aMode,allowUpdates);
	if (aMode==EDbOpen)
		self->DoOpenL(aString,*aFieldMap,allowUpdates);	// complete standard rowset opening
	CleanupStack::Pop();
	return self;
	}

EXPORT_C COplRowSet::~COplRowSet()
	{
	delete iDbColSet;
	delete iMap;
	if (iDbRowSet)
		{
		iDbRowSet->Close();
		delete iDbRowSet;
		}
	if (iParentDbase)
		{
		TRAPD(err,iDbCollect.CloseDbIfNotInUseL(iParentDbase,*TheRuntime()));
		}
	}

EXPORT_C void COplDbManager::OpenCheckL()
	{
	if (iLogicalNames->Count()==0)
		User::Leave(KOplErrClosed);
	}

EXPORT_C TInt COplFieldMap::ScanForOrdinal(const TDesC& aOplFieldName)
	{
	TInt count=iFieldInfoArray.Count();
	for (TInt kk=0;kk<count;kk++)
		{
		if (aOplFieldName==iFieldInfoArray[kk].OplName())
			return kk+1;
		}
	User::Leave(KOplErrNoFld);		
 	return -1; // WHY?
	}

EXPORT_C void COplDbManager::StringFieldValueL(TDes& aBuf)
	{
	TInt16 log(iStack.PopInt16());
	COplRowSet* oplRs=(iLogicalNames->FindRowSet(log));
	if (oplRs==NULL)
		User::Leave(KOplErrClosed);
	TPtrC fieldName(iStack.PopString());
	TInt ordinal=oplRs->GetOrdinal(fieldName);
	iStack.Push(fieldName);
	iStack.Push(log);
	if(!oplRs->InAppendOrUpdate())
		oplRs->AccessDbRowSet()->GetL();
	aBuf=(oplRs->AccessDbRowSet()->ColDes(ordinal));
	}

LOCAL_C COplFieldMap* buildFieldMapLC(COplRuntime& aRuntime)
	{
	TUint8* pMap=aRuntime.IP();
	TInt fCount=0;
	while (aRuntime.IP8()!=0x0ff)
		{
		TInt lbc=aRuntime.IP16(); //includes lbc2
		__ASSERT_DEBUG(lbc<=KOplMaxStrLen,AlignPanic(KErrOplAlignBadLength));
		aRuntime.IncIP(lbc*sizeof(TText));
		++fCount;
		}
	COplFieldMap* fm=COplFieldMap::NewLC(fCount);

	TInt type;
	while ((type=*pMap++)!=0x0ff)				
		{
		TBuf<KOplMaxFieldName> fieldname;
		TInt16 len=OplUtil::GetWord(pMap);
		__ASSERT_DEBUG(len<=KOplMaxStrLen,AlignPanic(KErrOplAlignBadLength));
		pMap+=2;
		for (TInt ii=len;ii;--ii)
			{
			TChar cc=*pMap++;
			cc=cc|*pMap++<<8;
			fieldname.Append(cc);
			}
		fm->AppendFieldL(fieldname,type);
		}
	return fm;
	} 

EXPORT_C void COplFieldMap::AppendFieldL(TDesC &aName, TInt aType)
	{
	TOplFieldInfo info(aName, aType);
	iFieldInfoArray.AppendL(info);
	}

EXPORT_C TDbColType COplFieldMap::ReadType(TInt aMapIndex)
/*
Reads type from Opl map and returns Dbms equivelant 				
*/ 
	{
	if (aMapIndex>=iFieldInfoArray.Count())
		return EDbColInt16;
	// K.K	static const TDbColType types[] = {EDbColInt16,EDbColInt32,EDbColReal64,EDbColText8,EDbColBit};
			static const TDbColType types[] = {EDbColInt16,EDbColInt32,EDbColReal64,EDbColText,EDbColBit};
	return types[iFieldInfoArray[aMapIndex].Type()];
	}

EXPORT_C void COplFieldMap::ReadName(TInt aMapIndex, TDes& aColName)
/*
Reads name from Opl map and generates acceptable dbms name
*/ 
	{
	TLex name=(iFieldInfoArray[aMapIndex].OplName());
	TChar cc;
	while (!name.Eos())										
		{
		cc=name.Get();										
		switch(cc)
			{
		case '%':
			cc='i';
			break;
		case '&':
			cc='l';
			break;
		case '$':
			cc='s';
			break;				
		default:
			break;
			} 
		aColName.Append(cc);									
		}
	}

LOCAL_C TPtrC nextCol(TLex& aColSpec,TInt& aStringLength,TDbColType& aType)
/*
 PARSE COMMAND STRING TO BUILD DBMS COL. SET
*/
	{
	TChar c;
	aColSpec.SkipSpaceAndMark();							
	while (!aColSpec.Eos() && ((c=aColSpec.Peek())!=','))	
		{
		if (c==EKeySpace || c==EKeyTab || c=='(')									
			break;
		aColSpec.Inc();
		}

	TPtrC ret= aColSpec.MarkedToken();
	aStringLength=KOplMaxStringFieldLength;
	aColSpec.SkipSpace();
	if ((c=aColSpec.Peek())=='(')
		{
		if (aType!=EDbColText)
			User::Leave(KOplErrSyntax);						
		aColSpec.Get();
		aColSpec.SkipSpaceAndMark();							
		while (!aColSpec.Eos() && ((c=aColSpec.Peek())!=')'))	
			{
			if (c==EKeySpace || c==EKeyTab )									
			break;
			aColSpec.Inc();	
			}

		TLex lex(aColSpec.MarkedToken());

		aColSpec.SkipSpace();
		if (aColSpec.Get()!=')')
			User::Leave(KOplErrSyntax);
		if (lex.Val(aStringLength)<0)
			User::Leave(KOplErrSyntax);
		if (aStringLength>KOplMaxStringFieldLength)
			User::Leave(KOplErrSyntax);
		}
	return ret;
	}

LOCAL_C void parseColSpecL(TLex& aColSpec, CDbColSet& aDbColSet, COplFieldMap& aFieldMap)
// Parse column specification into aDbColSet
	{
	aDbColSet.Clear();
	TInt i(0);
	TInt stringLength;
	FOREVER
		{
		TDbColType type=aFieldMap.ReadType(i);
		TPtrC ptrCol = nextCol(aColSpec,stringLength,type);
		if (!ptrCol.Length())										
			break;
		TDbCol aCol(ptrCol,type,stringLength); 
		aDbColSet.AddL(aCol); 											
		aColSpec.SkipSpace();											
		i++;															
		if (aColSpec.Peek()!=',')										
			break;
		aColSpec.Inc();
		}
	if (!i)
		User::Leave(KOplErrSyntax);
	if (aDbColSet.Count()!=aFieldMap.GetNoOfFields())
		User::Leave(KOplErrSyntax);
	}

_LIT(KTo,"TO");
_LIT(KSelectSpace,"SELECT ");
_LIT(KComma,",");
_LIT(KFrom," FROM ");
_LIT(KFields,"FIELDS");
_LIT(KTable1,"Table1");
_LIT(KFolded,"FOLDED");
_LIT(KCollated,"COLLATED");
_LIT(KSelect,"SELECT");
_LIT(KOr," OR ");
_LIT(KLikeQuote," LIKE \'");
_LIT(KQuote,"\'");

LOCAL_C TPtrC parseTableName(TLex& aColSpecRem)
// Parse the table name
	{
	TPtrC keyword2;
	keyword2.Set(aColSpecRem.NextToken());
	if (keyword2.CompareF(KTo))
		User::Leave(KOplErrSyntax);
	return(aColSpecRem.NextToken());
	}

LOCAL_C void makeQuery(CDbColSet& aDbColSet,TDesC& aTableName,TDes& aQuery)
// make/generate query
	{
 	TInt count=aDbColSet.Count();
	aQuery.Append(KSelectSpace);
	for(TInt i=1;i<count;i++)
		{
		aQuery.Append(aDbColSet[i].iName);
		aQuery.Append(KComma);
		}
	aQuery.Append(aDbColSet[count].iName);
	aQuery.Append(KFrom);
	aQuery.Append(aTableName);
	}

LOCAL_C void generateColSpecL(CDbColSet& aDbColSet, COplFieldMap& aFieldMap)
//GENERATE COL. SPEC TO MAKE DBMS COL. SET
	{
	TInt c=aFieldMap.GetNoOfFields();
	aDbColSet.Clear();									
	for(TInt i=0;i<c;i++)
		{
		TBuf<KDbMaxColName> aColName;
		aFieldMap.ReadName(i,aColName);
		TDbCol aCol(aColName,aFieldMap.ReadType(i),KOplMaxStringFieldLength);
		aDbColSet.AddL(aCol); 							
		}
	}

void COplRowSet::DoCreateL(TLex& aLex,TParse& aParse,COplFieldMap& aFieldMap)
	{
 	iParentDbase=iDbCollect.CreateOrOpenDbaseL(aParse.FullName(),EDbCreate,ETrue); 
	iDbColSet=CDbColSet::NewL();
	TPtrC keyword1;
	keyword1.Set(aLex.NextToken());
	if (keyword1.Length()!=0)
		{
		if (keyword1.CompareF(KFields))
			User::Leave(KOplErrSyntax);
		parseColSpecL(aLex,*iDbColSet,aFieldMap);
		TBufC<KOplMaxTableName> tableName=parseTableName(aLex);
		User::LeaveIfError(iParentDbase->CreateTable(tableName,*iDbColSet));
		TBuf<256> aQuery;
		makeQuery(*iDbColSet,tableName,aQuery);
 		iDbRowSet = new (ELeave) RDbView;
		User::LeaveIfError(((RDbView*)iDbRowSet)->Prepare((RDbStoreDatabase&)iParentDbase->Dbase(),aQuery));			
		User::LeaveIfError(((RDbView*)iDbRowSet)->EvaluateAll());			
		iAmATable=EFalse;
		}
 	else
		{
		generateColSpecL(*iDbColSet,aFieldMap);
		TBufC<KOplMaxTableName> tableName(KTable1);
		User::LeaveIfError(iParentDbase->CreateTable(tableName,*iDbColSet)); 
		iDbRowSet = new (ELeave) RDbTable;
		User::LeaveIfError(((RDbTable*)iDbRowSet)->Open((RDbStoreDatabase&)iParentDbase->Dbase(),tableName));		
		iAmATable=ETrue;
		}
	}

void COplRowSet::DoOpenL(const TDesC& aString,COplFieldMap& aFieldMap, TBool allowUpdates)
	{
	TLex lex(aString);

	lex.SkipSpaceAndMark();
	if (lex.Peek()=='"')
		{
		TInt posB=aString.LocateReverse('"');
		lex=aString.Mid(posB+1);
		}
	else
		lex.NextToken();

	TPtrC query(lex.Remainder());
	TPtrC keyword1;
	RDbRowSet::TAccess access=(allowUpdates)?RDbRowSet::EUpdatable:RDbRowSet::EReadOnly;
	TBool isTable;
	keyword1.Set(lex.NextToken()); // FIND OUT ABOUT TOKEN LENGTH
	if (keyword1.Length()!=0)
		{
		TDbTextComparison comp=EDbCompareNormal;
		if (keyword1.CompareF(KFolded)==0)
			{
			comp=EDbCompareFolded;
			query.Set(lex.Remainder());
			keyword1.Set(lex.NextToken()); 
			}
		else if (keyword1.CompareF(KCollated)==0)
			{
			comp=EDbCompareCollated;
			query.Set(lex.Remainder());
			keyword1.Set(lex.NextToken()); 
			}
		if (keyword1.CompareF(KSelect))
			User::Leave(KOplErrSyntax);
		RDbView* view = new (ELeave) RDbView;
		iDbRowSet = view;
		TDbQuery dbQuery(query,comp);
		User::LeaveIfError(view->Prepare((RDbStoreDatabase&)iParentDbase->Dbase(),dbQuery, access));
		User::LeaveIfError(view->EvaluateAll());
		isTable=EFalse;
		}
 	else
		{
		RDbTable* table = new (ELeave) RDbTable;
		iDbRowSet=table;
		User::LeaveIfError(table->Open((RDbStoreDatabase&)iParentDbase->Dbase(),KTable1, access));	// Allow updates default - ETRUE
		isTable=ETrue;
		}
	OpenRowSetL(iDbRowSet,isTable,&aFieldMap);
	}
 
EXPORT_C void COplRowSet::ExpandFieldMapToCoverRichText(COplFieldMap& aFieldMap)
	{
	for (TInt ii=1;ii<=iDbColSet->Count();ii++)			// check handles are of correct type
		{
		TDbColType type=((*iDbColSet)[ii].iType);
		if (type!=EDbColInt16 && type!=EDbColInt32 && type!=EDbColReal64 && type!=EDbColText && ii<=(aFieldMap.GetNoOfFields()+1))
			aFieldMap.InsertBlankL(ii-1,(*iDbColSet)[ii].iName);
		}
	}

EXPORT_C void COplFieldMap::InsertBlankL(TInt anOrdinal,const TDesC &aName)					
	{ //for data app files rich text + other type problems
	TOplFieldInfo ins(aName,4);
	ins.SetType(4);
	iFieldInfoArray.InsertL(anOrdinal,ins);
	}

void COplDbManager::OpenL(TOplDbOpenMode aMode,TBool allowUpdates)
// handle Create, Open, OpenR keyword 
	{
	TInt logName=iRuntime.IP8();
	COplFieldMap* fieldMap=buildFieldMapLC(iRuntime);
	if (iLogicalNames->FindRowSet(logName)!=NULL)
		User::Leave(KOplErrOpen);
	TPtrC stringPtr(iStack.PopString());
	COplRowSet* oplRowSet=COplRowSet::NewL(*iOplDbCollection,iFs,stringPtr,fieldMap,aMode,allowUpdates);
	oplRowSet->SetOplFieldMap(fieldMap);
	CleanupStack::Pop(); // fieldMap
	iLogicalNames->AddRowSet(logName,oplRowSet); // append dbase to collection
	iLogicalNames->SetCurrLogName(logName);
	iCurrOplRowSet=oplRowSet; // cached copy
	iCurrDbRowSet=oplRowSet->AccessDbRowSet(); // cached copy
	NextL();
	iRuntime.ClearTrap();
	}

EXPORT_C void COplDbManager::UseLog(TInt aLogicalName)
	{
	COplRowSet* rs;
	if ((rs=iLogicalNames->FindRowSet(aLogicalName))==NULL)
		User::Leave(KOplErrClosed);
	iLogicalNames->SetCurrLogName(aLogicalName);
	iCurrOplRowSet=rs;
	iCurrDbRowSet=rs->AccessDbRowSet();
	}

EXPORT_C void COplDbManager::SetiLogNames(CLogicalNames* aLogicalNames)
	{
	iLogicalNames=aLogicalNames;
	TOplCurrRowSet curr=iLogicalNames->GetCurrLogName();
	if (curr!=EDbNone)
		{
		iCurrOplRowSet=iLogicalNames->FindRowSet(curr);
		iCurrDbRowSet=iCurrOplRowSet->AccessDbRowSet();
		}
	}