1 /*

     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 /**

    20  @file

    21  @internalComponent

    22  @released

    23 */

    24 

    25 #include <e32base.h>

    26 #include <e32cons.h>

    27 #include "cntsqlprovider.h"

    28 

    29 /**

    30 Constant descriptor representing 'update' sql key word. Used to build sql statements.

    31 

    32 @internalComponent

    33 @released

    34 */	

    35 _LIT(KSqlUpdate, "UPDATE");

    36 

    37 

    38 /**

    39 Constant descriptor representing 'delete' sql key word. Used to build sql statements.

    40 

    41 @internalComponent

    42 @released

    43 */	

    44 _LIT(KSqlDelete, "DELETE");

    45 

    46 

    47 /**

    48 Constant descriptor representing 'insert' sql key word. Used to build sql statements.

    49 

    50 @internalComponent

    51 @released

    52 */	

    53 _LIT(KSqlInsert, "INSERT");

    54 

    55 

    56 /**

    57 Constant descriptor representing 'select' sql key word. Used to build sql statements.

    58 

    59 @internalComponent

    60 @released

    61 */	

    62 _LIT(KSqlSelect, "SELECT");

    63 

    64 

    65 /**

    66 Constant descriptor used to build sql statements.

    67 

    68 @internalComponent

    69 @released

    70 */	

    71 _LIT(KSqlWhere, "WHERE");

    72 

    73 

    74 /**

    75 Constant descriptor used to build sql statements.

    76 

    77 @internalComponent

    78 @released

    79 */	

    80 _LIT(KSqlSet, "SET");

    81 

    82 

    83 /**

    84 Constant descriptor used to build sql statements.

    85 

    86 @internalComponent

    87 @released

    88 */	

    89 _LIT(KSqlInto, "INTO");

    90 

    91 

    92 /**

    93 Constant descriptor used to build sql statements.

    94 

    95 @internalComponent

    96 @released

    97 */	

    98 _LIT(KSqlValues, "VALUES");

    99 

   100 

   101 /**

   102 Constant descriptor used to build sql statements.

   103 

   104 @internalComponent

   105 @released

   106 */	

   107 _LIT(KSqlFrom, "FROM");

   108 

   109 

   110 /**

   111 Constant descriptor used to build sql statements.

   112 

   113 @internalComponent

   114 @released

   115 */	

   116 _LIT(KSpace, " ");

   117 

   118 

   119 /**

   120 Constant descriptor used to build sql statements.

   121 

   122 @internalComponent

   123 @released

   124 */	

   125 _LIT(KEqual, " = ");

   126 

   127 

   128 /**

   129 Constant descriptor used to build sql statements.

   130 

   131 @internalComponent

   132 @released

   133 */	

   134 _LIT(KSemicolon, ";");

   135 

   136 

   137 /**

   138 Constant descriptor used to build sql statements.

   139 

   140 @internalComponent

   141 @released

   142 */	

   143 _LIT(KComma, ",");

   144 

   145 

   146 /**

   147 Constant descriptor used to build sql statements.

   148 

   149 @internalComponent

   150 @released

   151 */	

   152 _LIT(KOpenBracket, "(");

   153 

   154 

   155 /**

   156 Constant descriptor used to build sql statements.

   157 

   158 @internalComponent

   159 @released

   160 */	

   161 _LIT(KCloseBracket, ")");

   162 

   163 /**

   164 TStatement type constructor,

   165 

   166 @param aSqlStatement Specifies the sql statement type: select, insert, delete, update.

   167 @param aTableName 	 Table against which sql statement will be built

   168 

   169 */

   170 TCntSqlStatementType::TCntSqlStatementType(TCntSqlStatement aSqlStatement, const TDesC& aTableName)

   171 	:

   172 	iSqlStatement(aSqlStatement), 

   173 	iTableName(aTableName)

   174 	{

   175 	}

   176 

   177 /**

   178 TSqlStatement setter. Set the TSqlStatement held by this class,

   179 

   180 @param aSqlStatement Specifies the sql statement type: select, insert, delete, update.

   181 

   182 */	

   183 void TCntSqlStatementType::SetSqlStatement(TCntSqlStatement aSqlStatement)

   184 	{

   185 	iSqlStatement = aSqlStatement;	

   186 	}

   187 	

   188 /**

   189 TSqlStatement getter. Returns the sql statement type held by this class,

   190 

   191 @return 	TSqlStatement type held by this class

   192 

   193 */

   194 TCntSqlStatement TCntSqlStatementType::SqlStatement() const

   195 	{

   196 	return iSqlStatement;	

   197 	}

   198 	

   199 /**

   200 Table name getter. Returns the table's name held by this class,

   201 

   202 @return 	TDesC containing the table's name held by this class

   203 

   204 */

   205 const TDesC& TCntSqlStatementType::TableName() const

   206 	{

   207 	return iTableName;	

   208 	}

   209 	

   210 /**

   211 Factory method used to construct and retrieve CCntSqlStatement based objects. 

   212 CCntSqlStatement objects are used to build and provide sql strings (sql statements) to be 

   213 used in RSqlStatement.

   214 

   215 @param aStatementType TStatementType containing thwe sql statement type requested and the

   216 					  table name against which sql query will be run.

   217 

   218 @return Pointer  to concrete CCntSqlStatement implementation used to retrieve sql strings.

   219 

   220 */		

   221 CCntSqlStatement* TSqlProvider::GetSqlStatementL(TCntSqlStatementType aStatementType)

   222 	{

   223 	CCntSqlStatement* cntSqlStatement = NULL;

   224 	

   225 	switch(aStatementType.SqlStatement())

   226 		{

   227 		case EInsert:

   228 			cntSqlStatement = CCntSqlInsert::NewL( aStatementType.TableName() );

   229 			break;

   230 		case EUpdate:

   231 			cntSqlStatement = CCntSqlUpdate::NewL( aStatementType.TableName() );

   232 			break;		

   233 		case EDelete:

   234 			cntSqlStatement = CCntSqlDelete::NewL( aStatementType.TableName() );

   235 			break;

   236 		case ESelect:

   237 			cntSqlStatement = CCntSqlSelect::NewL( aStatementType.TableName() );

   238 		}

   239 	

   240 	return(cntSqlStatement);

   241 	}

   242 

   243 /**

   244 SQL parameter setter. Set value for a specified sql parameter,

   245 

   246 @param aParam SQL parameter name

   247 @param aValue SQL parameter value. 

   248 

   249 @leave KErrNoMemory, an out of memory occured

   250 

   251 @panic USER 0 panic; in debug mode if number of specified parameters is not equal with 

   252 		number of parameter values

   253 		

   254 */	

   255 void CCntSqlStatement::SetParamL(const TDesC& aParam, const TDesC& aValue)

   256 	{

   257 	ASSERT( iParams->Count() == iValues->Count() ); // in debug mode check 

   258 													// if number of provided params is equal 

   259 													// with number of provided values

   260 

   261 	ASSERT( iProcessed == EFalse ); // in debug mode check if the statement wasn't processed yet

   262 	

   263 	iParams->AppendL(aParam);

   264 	iValues->AppendL(aValue);

   265 	}

   266 	

   267 /**

   268 Utility method used to retrieve the position of a given parameter.

   269 The array of parameters is searched sequentially because we have to provide

   270 the index of the parameter as it was inserted (so binary search is not usefull here)

   271 Limit the usage of this method since it can be time consuming.

   272 

   273 @param  aParam parameter name for which index has to be retrieved

   274 @return index of the parameter if this is found in the parameter array (eg. previous set)

   275 		or KErrNotFound if the parameter was not found

   276 */

   277 TInt CCntSqlStatement::ParameterIndex(const TDesC& aParam) const

   278 	{

   279 	ASSERT( iParams->Count() == iValues->Count() ); // in debug mode check 

   280 													// if number of provided params is equal 

   281 													// with number of provided values

   282 	for(TInt i = 0; i < iParams->Count(); ++i)

   283 		{

   284 		if(aParam.Compare((*iParams)[i]) == 0)

   285 			{

   286 			return i;				

   287 			}

   288 		}

   289 		

   290 	return KErrNotFound;

   291 	}

   292 

   293 /**		

   294 SQL condition setter, Set condition for a sql statement (to be used in where clause)

   295 

   296 @param aCondition condition value.

   297 

   298 @leave KErrNoMemory, an out of memory occured

   299 

   300 */	

   301 void CCntSqlStatement::SetConditionL(const TDesC& aCondition)

   302 	{

   303 	ClearCondition();

   304 	iCondition = aCondition.AllocL();

   305 	ClearSqlString();

   306 	}

   307 

   308 /**		

   309 Clearing SQL condition from a sql statement 

   310 */	

   311 void CCntSqlStatement::ClearCondition()

   312 	{

   313 	if(iCondition)

   314 		{

   315 		delete iCondition;	

   316 		iCondition = NULL;

   317 		ClearSqlString();

   318 		} 

   319 	}

   320 

   321 	

   322 /**

   323 Remove all sql parameters prviously set and their values. Also reset previously set 

   324 sql condition.

   325 

   326 */	

   327 void CCntSqlStatement::Reset()

   328 	{

   329 	delete iCondition;	

   330 	iCondition = NULL;

   331 	

   332 	ClearSqlString();

   333 		

   334 	ClearParams();

   335 	}

   336 

   337 void CCntSqlStatement::ClearParams()

   338     {

   339     ClearSqlString();

   340         

   341     iParams->Reset();

   342     iValues->Reset();

   343     }

   344 

   345 /**

   346 Second phase constructor for CCntSqlStatement based classes

   347 

   348 @param aTableName table name against which sql statement will be run

   349 

   350 @leave KErrNoMemory, an out of memory occured

   351 

   352 */		

   353 void CCntSqlStatement::ConstructL(const TDesC& aTableName)

   354 	{

   355 	const TInt KGranularity = 5;

   356 	

   357 	iTableName = aTableName.AllocL();	

   358 	iParams = new (ELeave) CDesCArrayFlat(KGranularity);

   359 	iValues = new (ELeave) CDesCArrayFlat(KGranularity);	

   360 	

   361 	// Lazy initialisation for iSqlString; iSqlString is initialised in SqlStringL() method.

   362 	// This is done because in SqlStringL() method we know what size buffer must have

   363 	

   364 	iProcessed = EFalse;

   365 	}

   366 			

   367 /**

   368 CCntSqlStatement destructor.

   369 

   370 */	

   371 CCntSqlStatement::~CCntSqlStatement()

   372 	{

   373 	delete iTableName;	

   374 	delete iCondition;	

   375 	delete iSqlString;	

   376 	

   377 	if (iParams)

   378 		{

   379 		iParams->Reset();	

   380 		delete iParams;	

   381 		}

   382 	

   383 	if (iValues)

   384 		{

   385 		iValues->Reset();

   386 		delete iValues;		

   387 		}

   388 	}

   389 	

   390 void CCntSqlStatement::SetTableName(HBufC* aTableName)

   391     {

   392     delete iTableName;

   393     iTableName = aTableName;

   394     

   395 	// Table name changes, so SQL statement must be re-generated

   396 	ClearSqlString();

   397     }

   398 

   399 void CCntSqlStatement::ClearSqlString()

   400 	{

   401 	iProcessed = EFalse;

   402 	delete iSqlString;

   403 	iSqlString = NULL;

   404 	}

   405 

   406 /**

   407 Creates a concrete CCntSqlUpdate object (used to retrieve sql update statements)

   408 

   409 @param aTableName table name against which update statement will be run

   410 

   411 @return concrete CCntSqlUpdate object

   412 

   413 @leave KErrNoMemory, an out of memory occured

   414 

   415 */		

   416 CCntSqlUpdate* CCntSqlUpdate::NewL(const TDesC& aTableName)

   417 	{

   418 	CCntSqlUpdate* self = new (ELeave) CCntSqlUpdate();

   419 	CleanupStack::PushL(self );

   420 	self->ConstructL(aTableName);

   421 	CleanupStack::Pop(self);

   422 	return self;

   423 	}

   424 	

   425 /**

   426 Return a string representing an update sql statement

   427 

   428 @leave KErrArgument if the no parameter was provided

   429 */		

   430 TDesC& CCntSqlUpdate::SqlStringL()

   431 	{

   432 	if(iProcessed)

   433 		{

   434 		return *iSqlString;	

   435 		}

   436 		

   437 	ASSERT( iParams->Count() == iValues->Count() ); // in debug mode check 

   438 													// if number of provided params is equal 

   439 													// with number of provided values

   440 	

   441 	if(iParams->Count() == 0)

   442 		{

   443 		User::Leave( KErrArgument );	

   444 		}

   445 	

   446 	// First calculate the buffer size

   447 	TInt bufferSize = 0;

   448 	bufferSize = KSqlUpdate().Size() + 

   449 				iTableName->Size() + 

   450 				KSpace().Size() + 

   451 				KSqlSet().Size() + 

   452 				KSpace().Size();

   453 	

   454 	for(TInt loop = 0; loop < iParams->Count(); ++loop) 

   455 		{

   456 		bufferSize += (*iParams)[loop].Size() + 

   457 					KEqual().Size() + 

   458 					(*iValues)[loop].Size();

   459 		if(loop < iParams->Count() -1)

   460 			{

   461 			bufferSize += KComma().Size();		

   462 			}

   463 		}

   464 	if(iCondition)

   465 		{

   466 		bufferSize += KSpace().Size() + 

   467 					KSqlWhere().Size() + 

   468 					KSpace().Size() + iCondition->Size();

   469 		}

   470 	bufferSize += KSemicolon().Size();

   471 	

   472 	// Allocate buffer

   473 	iSqlString = HBufC::NewL( bufferSize );		

   474 	

   475 	TPtr dataPtr = iSqlString->Des();

   476 	

   477 	dataPtr.Append(KSqlUpdate);

   478 	dataPtr.Append(KSpace);

   479 	dataPtr.Append(*iTableName);

   480 	dataPtr.Append(KSpace);

   481 	dataPtr.Append(KSqlSet);

   482 	dataPtr.Append(KSpace);

   483 	

   484 	for(TInt loop = 0; loop < iParams->Count(); ++loop) 

   485 		{

   486 		dataPtr.Append((*iParams)[loop]);

   487 		dataPtr.Append(KEqual);

   488 		dataPtr.Append((*iValues)[loop]);

   489 		if(loop < iParams->Count() -1)

   490 			{

   491 			dataPtr.Append(KComma);		

   492 			}

   493 		}

   494 	

   495 	if(iCondition)

   496 		{

   497 		dataPtr.Append(KSpace);

   498 		dataPtr.Append(KSqlWhere);

   499 		dataPtr.Append(KSpace);	

   500 		dataPtr.Append(*iCondition);

   501 		}

   502 	dataPtr.Append(KSemicolon);	

   503 

   504 	iProcessed = ETrue;

   505 	return *iSqlString;	

   506 	}	

   507 

   508 /**

   509 Creates a concrete CCntSqlDelete object (used to retrieve sql delete statements)

   510 

   511 @param aTableName table name against which delete statement will be run

   512 

   513 @return concrete CCntSqlDelete object

   514 

   515 @leave KErrNoMemory, an out of memory occured

   516 

   517 */		

   518 CCntSqlDelete* CCntSqlDelete::NewL(const TDesC& aTableName)

   519 	{

   520 	CCntSqlDelete* self = new (ELeave) CCntSqlDelete();

   521 	CleanupStack::PushL(self);

   522 	self->ConstructL(aTableName);

   523 	CleanupStack::Pop(self);

   524 	return self;	

   525 	}

   526 	

   527 /**

   528 Return a string representing a delete sql statement

   529 

   530 @leave	KErrArgument if condition is not set

   531 */			

   532 TDesC& CCntSqlDelete::SqlStringL()

   533 	{

   534 	if(iProcessed) 

   535 		{

   536 		return *iSqlString;	

   537 		}

   538 

   539 	if(!iCondition)

   540 		{

   541 		User::Leave(KErrArgument);		

   542 		}	

   543 	

   544 	// First calculate the buffer size

   545 	TInt bufferSize = 0;

   546 	bufferSize = KSqlDelete().Size() + 

   547 				KSpace().Size() + 

   548 				KSqlFrom().Size() +

   549 				KSpace().Size() +

   550 				iTableName->Size() +

   551 				KSpace().Size() + 

   552 				KSqlWhere().Size() +

   553 				KSpace().Size() + 

   554 				iCondition->Size() + 

   555 				KSemicolon().Size();

   556 	

   557 	// Allocate buffer

   558 	iSqlString = HBufC::NewL( bufferSize );

   559 	

   560 	TPtr dataPtr = iSqlString->Des();

   561 	

   562 	dataPtr.Append(KSqlDelete);

   563 	dataPtr.Append(KSpace);

   564 	dataPtr.Append(KSqlFrom);

   565 	dataPtr.Append(KSpace);

   566 	dataPtr.Append(*iTableName);

   567 	

   568 	dataPtr.Append(KSpace);

   569 	dataPtr.Append(KSqlWhere);

   570 	dataPtr.Append(KSpace);	

   571 	dataPtr.Append(*iCondition);

   572 	dataPtr.Append(KSemicolon);

   573 	

   574 	iProcessed = ETrue;

   575 	return *iSqlString;	

   576 	}

   577 

   578 /**

   579 Creates a concrete CCntSqlInsert object (used to retrieve sql insert statements)

   580 

   581 @param aTableName table name against which insert statement will be run

   582 

   583 @return concrete CCntSqlInsert object

   584 

   585 @leave KErrNoMemory, an out of memory occured

   586 

   587 */			

   588 CCntSqlInsert* CCntSqlInsert::NewL(const TDesC& aTableName)

   589 	{

   590 	CCntSqlInsert* self = new (ELeave) CCntSqlInsert();

   591 	CleanupStack::PushL(self);

   592 	self->ConstructL(aTableName);

   593 	CleanupStack::Pop(self);

   594 	return self;	

   595 	}

   596 	

   597 /**

   598 Return a string representing an insert sql statement

   599 

   600 @leave 	KErrArgument if the no parameter was provided

   601 */			

   602 TDesC& CCntSqlInsert::SqlStringL()

   603 	{

   604 	if(iProcessed)

   605 		{

   606 		return *iSqlString;	

   607 		}

   608 

   609 	ASSERT( iParams->Count() == iValues->Count() ); // in debug mode check 

   610 													// if number of provided params is equal 

   611 													// with number of provided values

   612 	

   613 	if(iParams->Count() == 0)

   614 		{

   615 		User::Leave( KErrArgument );	

   616 		}		

   617 	

   618 	// First calculate the buffer size

   619 	TInt bufferSize = 0;

   620 	bufferSize = KSqlInsert().Size() + 

   621 				KSpace().Size() +

   622 				KSqlInto().Size() +

   623 				KSpace().Size() + 

   624 				iTableName->Size() + 

   625 				KSpace().Size() +		

   626 				KOpenBracket().Size();

   627 	for(TInt loop = 0; loop < iParams->Count(); ++loop) 

   628 		{

   629 		bufferSize += (*iParams)[loop].Size() + (*iValues)[loop].Size();

   630 		if(loop < iParams->Count() - 1) 

   631 			{

   632 			bufferSize += KComma().Size() + KComma().Size();		

   633 			}

   634 		}

   635 	bufferSize += KCloseBracket().Size() + 

   636 				KSpace().Size() + 

   637 				KSqlValues().Size() +

   638 				KSpace().Size() + 	

   639 				KCloseBracket().Size() +

   640 				KSemicolon().Size();

   641 	

   642 	// Allocate buffer

   643 	iSqlString = HBufC::NewL( bufferSize );

   644 	

   645 	TPtr dataPtr = iSqlString->Des();

   646 	

   647 	dataPtr.Append(KSqlInsert);

   648 	dataPtr.Append(KSpace);

   649 	dataPtr.Append(KSqlInto);

   650 	dataPtr.Append(KSpace);

   651 	dataPtr.Append(*iTableName);

   652 	dataPtr.Append(KSpace);

   653 			

   654 	dataPtr.Append(KOpenBracket);

   655 	for(TInt loop = 0; loop < iParams->Count(); ++loop) 

   656 		{

   657 		dataPtr.Append((*iParams)[loop]);

   658 		if(loop < iParams->Count() - 1) 

   659 			{

   660 			dataPtr.Append(KComma);		

   661 			}

   662 		}

   663 		

   664 	dataPtr.Append(KCloseBracket);

   665 	

   666 	dataPtr.Append(KSpace);

   667 	dataPtr.Append(KSqlValues);

   668 	dataPtr.Append(KSpace);

   669 	

   670 	dataPtr.Append(KOpenBracket);

   671 	for(TInt loop = 0; loop < iValues->Count(); ++loop) 

   672 		{

   673 		dataPtr.Append((*iValues)[loop]);

   674 		if(loop < iValues->Count() - 1)

   675 			{

   676 			dataPtr.Append(KComma);		

   677 			}

   678 		}

   679 	

   680 	dataPtr.Append(KCloseBracket);

   681 	dataPtr.Append(KSemicolon);

   682 	

   683 	iProcessed = ETrue;

   684 	

   685 	return *iSqlString;	

   686 	}

   687 	

   688 /**

   689 Creates a concrete CCntSqlSelect object (used to retrieve sql select statements)

   690 

   691 @param aTableName table name against which select statement will be run

   692 

   693 @return concrete CCntSqlSelect object

   694 

   695 @leave KErrNoMemory, an out of memory occured

   696 

   697 */			

   698 CCntSqlSelect* CCntSqlSelect::NewL(const TDesC& aTableName)

   699 	{

   700 	CCntSqlSelect* self = new (ELeave) CCntSqlSelect();

   701 	CleanupStack::PushL(self);

   702 	self->ConstructL(aTableName);

   703 	CleanupStack::Pop(self);

   704 	return self;			

   705 	}

   706 	

   707 /**

   708 Return a string representing a select sql statement

   709 When constructing simple select statement (against one single table) table name 

   710 has to be provided.

   711 For making joint selects a list of tables will be provided: table1, table2 as

   712 table name.

   713 

   714 @leave	KErrArgument if there is no argument provided

   715 */			

   716 TDesC& CCntSqlSelect::SqlStringL()

   717 	{

   718 	if(iProcessed) 

   719 		{

   720 		return *iSqlString;	

   721 		}

   722 	

   723 	if(iParams->Count() == 0)

   724 		{

   725 		User::Leave(KErrArgument);	

   726 		}

   727 	

   728 	// First calculate the buffer size

   729 	TInt bufferSize = 0;

   730 	bufferSize = KSqlSelect().Size() +

   731 				KSpace().Size();

   732 	for(TInt loop = 0; loop < iParams->Count(); ++loop) 

   733 		{

   734 		bufferSize += (*iParams)[loop].Size();

   735 		if(loop < iParams->Count() - 1)

   736 			{

   737 			bufferSize += KComma().Size();		

   738 			}

   739 		}	

   740 	bufferSize += KSpace().Size() + 

   741 				KSqlFrom().Size() +

   742 				KSpace().Size() +

   743 				iTableName->Size();

   744 	if(iCondition)

   745 		{

   746 		bufferSize += KSpace().Size() + 

   747 					KSqlWhere().Size() +

   748 					KSpace().Size() + 

   749 					iCondition->Size();

   750 		}

   751 	bufferSize += KSemicolon().Size();

   752 	

   753 	// Allocate buffer

   754 	iSqlString = HBufC::NewL( bufferSize );

   755 	TPtr dataPtr = iSqlString->Des();

   756 	

   757 	dataPtr.Append(KSqlSelect);

   758 	dataPtr.Append(KSpace);

   759 

   760 	for(TInt loop = 0; loop < iParams->Count(); ++loop) 

   761 		{

   762 		dataPtr.Append((*iParams)[loop]);

   763 		if(loop < iParams->Count() - 1)

   764 			{

   765 			dataPtr.Append(KComma);		

   766 			}

   767 		}	

   768 	

   769 	dataPtr.Append(KSpace);

   770 	

   771 	dataPtr.Append(KSqlFrom);

   772 	dataPtr.Append(KSpace);

   773 	dataPtr.Append(*iTableName);

   774 

   775 	if(iCondition)

   776 		{

   777 		dataPtr.Append(KSpace);

   778 		dataPtr.Append(KSqlWhere);

   779 		dataPtr.Append(KSpace);	

   780 		dataPtr.Append(*iCondition);

   781 		}

   782 	dataPtr.Append(KSemicolon);	

   783 			

   784 	iProcessed = ETrue;

   785 	

   786 	return *iSqlString;	

   787 	}