// Called by BasicSQL2.script.

// Tests that  a transaction which is not completed   is visible to a EReadUncommitted

// session and simultaneously (so a bit of concurrency), not visible

// to a EReadSerializable session.

// Set up a new database.

[Thread1]

WaitB0=2

Delete1=C:\Transaction0.db

ExpectedError1=KErrNotFound

Create2=C:\Transaction0.db

Exec3=Create Table Curtab(f1 int primary key, f2 real, f3 text);

Prepare4=Insert into Curtab(f1, f2, f3) values(:mary, :mungo, :midge);

ParameterIndex5=:mary

ParameterIndex6=:mungo

ParameterIndex7=:midge

BindInt8=0,-4853

BindReal9=1,6.0827626

BindText10=2,Here's some text

St_Exec11=

Reset12=

St_Close13=

// At this point one record outside of a transaction is present.

NoOperation14=

Exec15=Begin Transaction;

Prepare16=Insert into Curtab(f1, f2, f3) values(:mary, :mungo, :midge);

ParameterIndex17=:mary

ParameterIndex18=:mungo

ParameterIndex19=:midge

BindInt20=0,9876

BindReal21=1,7.0710678

BindText22=2,Here's yet more text

St_Exec23=

Reset24=

BindInt25=0,1011010

BindReal26=1,182282.397

BindText27=2,I want chocolate. Now.

St_Exec28=

Reset29=

BindInt30=0,7070707

BindReal31=1,-1.60217733e-19

BindText32=2,Now I want ice-cream.

St_Exec33=

Reset34=

St_Close35=

// At this point we've added one row outside of the transaction and 3 more

// within it. Send a signal to the slave threads which will check for the

// above content (one is ESerializable, one is EReadUncommitted, so they'll

// see different content).

// Wake up 2 threads..

SignalA36=2

// Wait for two signals to show they've finished..

WaitB37=2

Exec38=Rollback;

Close39=

EndBlock40=

// ESerializable thread.

[Thread2]

SignalB0=1

// Wait until the db has been setup.

WaitA1=1

Open2=C:\Transaction0.db

SetIsolationLevel3=ESerializable

Prepare4=Select * from Curtab;

ColumnIndex5=f1

ColumnIndex6=f2

ColumnIndex7=f3

Next8=

ExpectedError8=KSqlErrLocked

St_Close9=

Close10=

SignalB11=1

EndBlock12=

[Thread3]

SignalB0=1

// Wait until the db has been setup.

WaitA1=1

Open2=C:\Transaction0.db

SetIsolationLevel3=EReadUncommitted

Prepare4=Select * from Curtab;

ColumnIndex5=f1

ColumnIndex6=f2

ColumnIndex7=f3

Next8=KSqlAtRow

ColumnInt9=0,-4853

ColumnReal10=1,6.0827626

ColumnTextL11=2,Here's some text

Next12=KSqlAtRow

ColumnInt13=0,9876

ColumnReal14=1,7.0710678

ColumnTextL15=2,Here's yet more text

Next16=KSqlAtRow

ColumnInt17=0,1011010

ColumnReal18=1,182282.397

ColumnTextL19=2,I want chocolate. Now.

Next20=KSqlAtRow

ColumnInt21=0,7070707

ColumnReal22=1,-1.60217733e-19

ColumnTextL23=2,Now I want ice-cream.

Next24=KSqlAtEnd

St_Close25=

Close26=

SignalB27=1

EndBlock28=

[CheckFollowingRollback]

Open0=C:\Transaction0.db

NoOperation1=

NoOperation2=

Prepare3=Select * from Curtab;

ColumnIndex4=f1

ColumnIndex5=f2

ColumnIndex6=f3

Next7=KSqlAtRow

ColumnInt8=0,-4853

ColumnReal9=1,6.0827626

ColumnTextL10=2,Here's some text

Next11=KSqlAtEnd

St_Close12=

Close13=

Delete14=C:\Transaction0.db

EndBlock15=

// Create some cells with text in. Copy these with streams - passing

// an RSqlColumnReadStream to an RSqlParamWriteStream.

[CopyCellsWithStreams]

Delete0=C:\CopyCells.db

ExpectedError0=KErrNotFound

Create1=C:\CopyCells.db

Exec2=Create table Table1(field1 text(50));

Exec3=Create table Table2(field1 text(50));

Exec4=Insert Into Table1(field1) values("We're going to copy this string");

Exec5=Insert Into Table1(field1) values("And this one");

Exec6=Insert Into Table1(field1) values("In fact, all of them. There's a loop");

// This is used to select the field we want to copy.

Prepare7=select field1 from Table1;

NoOperation8=

// This will copy the first cell into a new one (using a separate

// RSqlStatement object). The two lines below define values for the separate

// RSqlStatement to use.

Function9=CopyCellsUsingStreams

PrepareStatement=Insert into Table2(field1) values(:mob);

ParamName=:mob

// Close Prepare6 and read back the content of Table2 to see if the cell

// copied correctly.

St_Close10=

Prepare11=select field1 from Table2;

Next12=KSqlAtRow

ColumnIndex13=field1

ColumnTextL14=0,We're going to copy this string

Next15=KSqlAtRow

ColumnTextL16=0,And this one

Next17=KSqlAtRow

ColumnTextL18=0,In fact, all of them. There's a loop

Next19=KSqlAtEnd

// Shut down our RSqlStatement and RSqlDatabase resources.

St_Close20=

Close21=

Delete22=C:\CopyCells.db

EndBlock23=

// A separate test, here we bind the content of one file (to an integer

// field actually, but SQLite doesn't care about that), then we bind the

// content of another before performing the exec/reset. So which data

// ends up in the cell? The data from the second bind.

[DoubleBind]

Delete0=C:\GenerateErrors2.db

ExpectedError0=KErrNotFound

Create1=C:\GenerateErrors2.db

Exec2=Create Table Table1(Field1 int);

Prepare3=Insert into Table1(Field1) Values (:Mickey);

ParameterIndex4=:Mickey

StreamWriteBindText5=0,Z:\TEF_SQL\TestData\reference1.bin

StreamWriteBindText6=0,Z:\TEF_SQL\TestData\reference1.txt

St_Exec7=

Reset8=

St_Close9=

Prepare10=select * from Table1;

ColumnIndex11=Field1

Next12=KSqlAtRow

ColumnTextL13=0,Z:\TEF_SQL\TestData\reference1.txt

St_Close14=

Close15=

Delete16=C:\GenerateErrors2.db

EndBlock17=-

// Test the 'leaving' version of Create, Prepare and Open, also see what

// happens if you try creating a database on ROM..

[LeaveMethods]

Delete0=C:\Leave1.db

ExpectedError0=KErrNotFound

OpenL1=C:\Leave1.db

ExpectedError1=KErrNotFound

CreateL2=C:\Leave1.db

Exec3=Create table Leavetable(f1 text(50), f2 int, f3 real);

PrepareL4=Insert into Leavetable values(:wonka, :charlie, :joe);

ParameterIndex5=:wonka

ParameterIndex6=:charlie

ParameterIndex7=:joe

BindText8=0,Great Glass Elevator

BindInt9=1,5

BindReal10=2,1.23456

St_Exec11=

Reset12=

BindText13=0,Chocolate Factory

BindInt14=1,54

BindReal15=2,9.87654

St_Exec16=

Reset17=

St_Close18=

PrepareL19=select * from Leavetable;

NoOperation20=

Next21=KSqlAtRow

ColumnIndex22=f1

ColumnIndex23=f2

ColumnIndex24=f3

ColumnTextL25=0,Great Glass Elevator

ColumnInt26=1,5

ColumnReal27=2,1.23456

Next28=KSqlAtRow

ColumnTextL29=0,Chocolate Factory

ColumnInt30=1,54

ColumnReal31=2,9.87654

Next32=KSqlAtEnd

St_Close33=

Close34=

CreateL35=C:\Leave1.db

ExpectedError35=KErrAlreadyExists

Delete36=C:\Leave1.db

CreateL37=Z:\TEF_SQL\TestData\ReadOnly.db

ExpectedError37=KErrAlreadyExists

CreateL38=Z:\TEF_SQL\TestData\DoesntExist.db

ExpectedError38=KErrAccessDenied

EndBlock39=

// Create (and implicitly open) a database, then another, then another, etc.

// This actually isn't supposed to generate errors.

// This leaks memory, normally the programmer would be expected to close

// each of the databases before opening another, but we're explicitly

// checking that successive Opens/Creates give no error.

[MultipleCreateOpen]

Delete0=C:\MCO1.db

ExpectedError0=KErrNotFound

Delete1=C:\MCO2.db

ExpectedError1=KErrNotFound

Delete2=C:\MCO3.db

ExpectedError2=KErrNotFound

Delete3=C:\MCO4.db

ExpectedError3=KErrNotFound

Delete4=C:\MCO5.db

ExpectedError4=KErrNotFound

CreateL5=C:\MCO1.db

Create6=C:\MCO2.db

OpenL7=Z:\TEF_SQL\TestData\test1.db

CreateL8=C:\MCO3.db

Create9=C:\MCO4.db

CreateL10=C:\MCO5.db

Delete11=C:\MCO1.db

ExpectedError11=KErrInUse

Delete12=C:\MCO2.db

ExpectedError12=KErrInUse

Delete13=C:\MCO3.db

ExpectedError13=KErrInUse

Delete14=C:\MCO4.db

ExpectedError14=KErrInUse

Delete15=C:\MCO5.db

ExpectedError15=KErrInUse

Close16=

Delete17=C:\MCO5.db

Open18=Z:\TEF_SQL\TestData\ReadOnly.db

OpenL19=Z:\TEF_SQL\TestData\test1.db

Open20=Z:\TEF_SQL\TestData\ReadOnly.db

NoOperation21=10000000

EndBlock22=

[ExtraBindTest]

WaitB0=1

SignalA1=1

// First set up a table.

Delete2=C:\ExtraBindTest.db

ExpectedError2=KErrNotFound

Create3=C:\ExtraBindTest.db

Exec4=Create table Sometable(Someint int, Somereal real, Sometext text);

Prepare5=Insert into Sometable(Someint, Somereal, Sometext) values (:FInt, :FReal, :FText);

Function6=WriteBigTable

LowCount=105

HighCount=119

CountStep=3

Multiplier=0.0

Text=Here's some rather pointless text

EventuallyExpectedError=KErrNone

St_Close7=

// Now try a non-trivial select. Ok then, fairly trivial, ;-)

Prepare8=Select * from Sometable where Someint > :Brian;

ParameterIndex9=:Brian

BindInt10=0,112

Next11=KSqlAtRow

ColumnIndex12=Someint

ColumnIndex13=Somereal

ColumnIndex14=Sometext

ColumnInt15=0,114

ColumnReal16=1,0.0

ColumnTextL17=2,Here's some rather pointless text

Next18=KSqlAtRow

ColumnInt19=0,117

ColumnReal20=1,0.0

ColumnTextL21=2,Here's some rather pointless text

Next22=KSqlAtEnd

St_Close23=

Close24=

Delete25=C:\ExtraBindTest.db

EndBlock26=

[ExtraBindTest2]

SignalB0=1

WaitA1=1

Delete2=C:\ExtraBindTest2.db

ExpectedError2=KErrNotFound

Create3=C:\ExtraBindTest2.db

Exec4=Create table Sometable(Someint int, Somereal real, Sometext text);

Prepare5=Insert into Sometable(Sometext) values (:FText);

ParameterIndex6=:FText

NewBlock7=WriteInts20

St_Exec8=

Reset9=

NewBlock10=WriteInts21

St_Exec11=

Reset12=

NewBlock13=WriteInts22

St_Exec14=

Reset15=

NewBlock16=WriteInts400

St_Exec17=

Reset18=

St_Close19=

Prepare20=Select * from Sometable;

ColumnIndex21=Sometext

Next22=KSqlAtRow

ColumnSize23=0,80

Next24=KSqlAtRow

ColumnSize25=0,84

Next26=KSqlAtRow

ColumnSize27=0,88

Next28=KSqlAtRow

ColumnSize29=0,1600

Next30=KSqlAtEnd

// MUST close the Statement or confusion ensues!!

St_Close31==

Prepare32=Select Sometext from Sometable where Sometext=:Block

ParameterIndex33=:Block

// We're trying to recover one of the blocks. This function does a bind..

NewBlock34=WriteInts21

Next35=KSqlAtRow

ColumnIndex36=Sometext

ColumnSize37=0,84

Next38=KSqlAtEnd

St_Close39=

Close40=

Delete41=C:\ExtraBindTest2.db

EndBlock42=

[WriteInts20]

Function0=WriteIntsToStream

Count=20

EndBlock1=

[WriteInts21]

Function0=WriteIntsToStream

Count=21

EndBlock1=

[WriteInts22]

Function0=WriteIntsToStream

Count=22

EndBlock1=

[WriteInts400]

Function0=WriteIntsToStream

Count=400

EndBlock1=