private void ParseScript(string name)
{
ScriptParser scriptParser = new ScriptParser();
bool flag = true;
bool flag2;
if (flag)
{
flag2 = scriptParser.Parse("Localization/" + name + ".txt", flag);
}
else
{
flag2 = scriptParser.Parse("Resources/Scripts/Localization/" + name + ".txt", flag);
}
if (!flag2)
{
scriptParser.Parse("Localization/Texts_EN.txt", true);
}
for (int i = 0; i < scriptParser.GetKeysCount(); i++)
{
Key key = scriptParser.GetKey(i);
if (key.GetName() == "String" && !this.m_LocalizedTexts.ContainsKey(key.GetVariable(0).SValue))
{
this.m_LocalizedTexts.Add(key.GetVariable(0).SValue, key.GetVariable(1).SValue);
}
}
}
public void GrantTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE FOO( a int)");
parser.Parse("GRANT SELECT ON foo TO public");
ScriptSet difference = parser.Database.CreateDiffScripts(new Database());
Assert.AreEqual(2, difference.Count);
Assert.AreEqual(difference[0].Type, ScriptType.Table);
Assert.AreEqual(@"CREATE TABLE [dbo].[FOO](
[a] [int] NULL
)
GO",
difference[0].Text);
Assert.AreEqual(difference[1].Type, ScriptType.Permission);
Assert.AreEqual(@"GRANT SELECT ON [dbo].[FOO] TO [public]
GO
",
difference[1].Text);
ExecuteScripts(difference);
ScriptParser database = ParseDatabase();
difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void TableGrantTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TYPE foo AS TABLE ( a int )");
parser.Parse("GRANT CONTROL ON TYPE::dbo.foo TO public");
Assert.AreEqual(1, parser.Database.Tables.Count);
ScriptSet difference = parser.Database.CreateDiffScripts(new Database());
Assert.AreEqual(2, difference.Count);
Assert.AreEqual(difference[0].Type, ScriptType.TableType);
Assert.AreEqual(@"CREATE TYPE [dbo].[foo] AS TABLE(
[a] [int] NULL
)
GO",
difference[0].Text);
Assert.AreEqual(difference[1].Type, ScriptType.Permission);
Assert.AreEqual(@"GRANT CONTROL ON TYPE::[dbo].[foo] TO [public]
GO
",
difference[1].Text);
ExecuteScripts(difference);
ScriptParser database = ParseDatabase();
difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void GrantTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE Function A (@B int) RETURNS int AS BEGIN RETURN @B END");
parser.Parse("GRANT Execute ON A TO public");
ScriptSet difference = parser.Database.CreateDiffScripts(new Database());
Assert.AreEqual(2, difference.Count);
Assert.AreEqual(difference[0].Type, ScriptType.UserDefinedFunction);
Assert.AreEqual(difference[1].Type, ScriptType.Permission);
Assert.AreEqual(@"GRANT Execute ON [dbo].[A] TO [public]
GO
",
difference[1].Text);
ExecuteScripts(difference);
ScriptParser database = ParseDatabase();
difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void PermissionTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TABLE foo( a int)");
ScriptParser currentDatabase = new ScriptParser();
ExecuteScripts(startingDatabase.Database.CreateDiffScripts(currentDatabase.Database));
ScriptParser endingDatabase = new ScriptParser();
endingDatabase.Parse("CREATE TABLE foo( a int)");
endingDatabase.Parse("GRANT SELECT ON foo TO PUBLIC");
ScriptSet scripts = endingDatabase.Database.CreateDiffScripts(startingDatabase.Database);
Assert.AreEqual(1, scripts.Count);
Assert.AreEqual(scripts[0].Type, ScriptType.Permission);
ExecuteScripts(scripts);
currentDatabase = ParseDatabase();
ScriptSet difference = endingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void Not()
{
ScriptParser parser = new ScriptParser();
Assert.AreEqual(false, parser.Parse("!true").Execute());
Assert.AreEqual(true, parser.Parse("!false").Execute());
}
public void ViewTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE foo(a int)");
parser.Parse("CREATE VIEW bar WITH SCHEMABINDING AS SELECT a FROM dbo.foo");
parser.Parse("CREATE UNIQUE CLUSTERED INDEX bar_a ON dbo.bar(a)");
Assert.AreEqual(1, parser.Database.Views.Count);
Assert.AreEqual(1, parser.Database.Views[0].Indexes.Count);
ScriptParser database = ParseDatabase();
ScriptSet scripts = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(3, scripts.Count);
Assert.AreEqual(@"CREATE UNIQUE CLUSTERED INDEX [bar_a]
ON [dbo].[bar](
[a] ASC
)
",
scripts[2].Text);
ExecuteScripts(scripts);
database = ParseDatabase();
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void FilegroupTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE foo(a int)");
parser.Parse("CREATE INDEX foo_a ON dbo.foo(a) ON Primary");
Assert.AreEqual(1, parser.Database.Tables.Count);
Assert.AreEqual(1, parser.Database.Tables[0].Indexes.Count);
ExecuteScripts(parser.Database.Tables[0].GenerateCreateScript());
Script createScript = parser.Database.Tables[0].Indexes[0].GenerateCreateScript();
Assert.AreEqual(@"CREATE INDEX [foo_a]
ON [dbo].[foo](
[a] ASC
)
ON [Primary]
",
createScript.Text);
ExecuteScripts(createScript);
ScriptParser database = ParseDatabase();
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void AlterDefaultTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE foo( a int)");
parser.Parse("ALTER TABLE foo ADD CONSTRAINT DF_foo_a DEFAULT 0 FOR a");
Assert.AreEqual(1, parser.Database.Tables.Count);
Assert.AreEqual(1, parser.Database.Constraints.Count);
ScriptParser database = ParseDatabase();
ScriptSet scripts = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(2, scripts.Count);
Assert.AreEqual(ScriptType.Table, scripts[0].Type);
Assert.AreEqual(ScriptType.DefaultConstraint, scripts[1].Type);
Assert.AreEqual(@"ALTER TABLE [dbo].[foo]
ADD CONSTRAINT [DF_foo_a]
DEFAULT ( 0 )
FOR [a]",
scripts[1].Text);
ExecuteScripts(scripts);
database = ParseDatabase();
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void FunctionTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE FUNCTION dbo.checker(@val varchar(10)) RETURNS int AS BEGIN RETURN 1 END");
parser.Parse("CREATE TABLE foo( a varchar(10) CHECK ( dbo.checker(a) = 1))");
Assert.AreEqual(1, parser.Database.Tables.Count);
Assert.AreEqual(1, parser.Database.Constraints.Count);
Assert.AreEqual(1, parser.Database.Functions.Count);
ScriptParser database = ParseDatabase();
ScriptSet scripts = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(3, scripts.Count);
Assert.AreEqual(ScriptType.Table, scripts[0].Type);
Assert.AreEqual(ScriptType.CheckConstraint, scripts[1].Type);
Assert.AreEqual(@"ALTER TABLE [dbo].[foo]
ADD CONSTRAINT [CK_foo]
CHECK ( [dbo].[checker] ( [a] ) = 1 )",
scripts[1].Text);
Assert.AreEqual(ScriptType.UserDefinedFunction, scripts[2].Type);
Assert.AreEqual(@"CREATE FUNCTION dbo.checker(@val varchar(10)) RETURNS int AS BEGIN RETURN 1 END
GO",
scripts[2].Text);
ExecuteScripts(scripts);
database = ParseDatabase();
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void InlineForeignKeyTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE foo( a int primary key)");
parser.Parse("CREATE TABLE bar( a int foreign key references foo(a))");
Assert.AreEqual(2, parser.Database.Tables.Count);
Assert.AreEqual(2, parser.Database.Constraints.Count);
ScriptParser database = ParseDatabase();
ScriptSet scripts = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(4, scripts.Count);
scripts.Sort();
Assert.AreEqual(ScriptType.ForeignKey, scripts[3].Type);
Assert.AreEqual(@"ALTER TABLE [dbo].[bar]
ADD CONSTRAINT [FK_bar_foo]
FOREIGN KEY(
[a]
)
REFERENCES [dbo].[foo](
[a]
)",
scripts[3].Text);
ExecuteScripts(scripts);
database = ParseDatabase();
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void StoredProcedureWithTableTypeTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TYPE foo AS TABLE( a int)");
startingDatabase.Parse("CREATE PROCEDURE GetFoo(@a foo READONLY) AS SELECT * FROM @a");
ScriptSet scripts = startingDatabase.Database.CreateDiffScripts(new Database());
scripts.Sort();
Assert.AreEqual(2, scripts.Count);
ExecuteScripts(scripts);
ScriptParser modifiedDatabase = new ScriptParser();
modifiedDatabase.Parse("CREATE TYPE foo AS TABLE( a int, b int)");
modifiedDatabase.Parse("CREATE PROCEDURE GetFoo(@a foo READONLY) AS SELECT * FROM @a");
scripts = modifiedDatabase.Database.CreateDiffScripts(startingDatabase.Database);
scripts.Sort();
Assert.AreEqual(4, scripts.Count);
Assert.AreEqual(ScriptType.DropStoredProc, scripts[0].Type);
Assert.AreEqual(ScriptType.DropTableType, scripts[1].Type);
Assert.AreEqual(ScriptType.TableType, scripts[2].Type);
Assert.AreEqual(ScriptType.StoredProc, scripts[3].Type);
ExecuteScripts(scripts);
}
public void StoredProcedureWithSchemaTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TABLE foo( a int, b int)");
startingDatabase.Parse("CREATE TABLE guest.foo( a int, b int)");
startingDatabase.Parse("CREATE PROCEDURE GetFoo(@a int) AS SELECT * FROM foo WHERE a=@a");
startingDatabase.Parse("CREATE PROCEDURE guest.GetFoo(@a int) AS SELECT * FROM guest.foo WHERE a=@a");
ScriptSet scripts = startingDatabase.Database.CreateDiffScripts(new Database());
scripts.Sort();
Assert.AreEqual(4, scripts.Count);
ExecuteScripts(scripts);
ScriptParser modifiedDatabase = new ScriptParser();
modifiedDatabase.Parse("CREATE TABLE foo( a int, b int, c int)");
modifiedDatabase.Parse("CREATE TABLE guest.foo( a int, b int)");
modifiedDatabase.Parse("CREATE PROCEDURE GetFoo(@a int) AS SELECT * FROM foo WHERE a=@a");
modifiedDatabase.Parse("CREATE PROCEDURE guest.GetFoo(@a int) AS SELECT * FROM guest.foo WHERE a=@a");
scripts = modifiedDatabase.Database.CreateDiffScripts(startingDatabase.Database);
scripts.Sort();
Assert.AreEqual(5, scripts.Count);
Assert.AreEqual(ScriptType.DropStoredProc, scripts[0].Type);
Assert.AreEqual(ScriptType.TableSaveData, scripts[1].Type);
Assert.AreEqual(ScriptType.Table, scripts[2].Type);
Assert.AreEqual(ScriptType.TableRestoreData, scripts[3].Type);
Assert.AreEqual(ScriptType.StoredProc, scripts[4].Type);
ExecuteScripts(scripts);
}
public void CallIndexer()
{
ScriptParser parser = new ScriptParser(new Variable("test", new TestHost()));
parser.Parse("test[\"data\"]=8").Execute();
Assert.AreEqual(8, parser.Parse("test[\"data\"]").Execute());
}
public void ColumnCountTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TABLE foo(a int, b int)");
startingDatabase.Parse("CREATE INDEX foo_a ON dbo.foo(a)");
ScriptParser currentDatabase = new ScriptParser();
ExecuteScripts(startingDatabase.Database.CreateDiffScripts(currentDatabase.Database));
ScriptParser endingDatabase = new ScriptParser();
endingDatabase.Parse("CREATE TABLE foo(a int, b int)");
endingDatabase.Parse("CREATE INDEX foo_a ON dbo.foo(a, b)");
ScriptSet scripts = endingDatabase.Database.CreateDiffScripts(startingDatabase.Database);
scripts.Sort();
Assert.AreEqual(2, scripts.Count);
Assert.AreEqual(scripts[0].Type, ScriptType.DropIndex);
Assert.AreEqual(@"DROP INDEX [foo_a] ON [dbo].[foo]
", scripts[0].Text);
Assert.AreEqual(scripts[1].Type, ScriptType.Index);
//the actual script should be tested in the parser tests
ExecuteScripts(scripts);
currentDatabase = ParseDatabase();
ScriptSet difference = endingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void GrantTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE foo( a int)");
parser.Parse("CREATE PROCEDURE A (@B int) AS SELECT * FROM foo GO GRANT Execute ON A TO public");
ScriptSet difference = parser.Database.CreateDiffScripts(new Database());
Assert.AreEqual(3, difference.Count);
Assert.AreEqual(difference[0].Type, ScriptType.Table);
Assert.AreEqual(difference[1].Type, ScriptType.StoredProc);
Assert.AreEqual(difference[2].Type, ScriptType.Permission);
Assert.AreEqual(@"GRANT Execute ON [dbo].[A] TO [public]
GO
",
difference[2].Text);
ExecuteScripts(difference);
ScriptParser database = ParseDatabase();
difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void NameOverlapTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE foo(a int)");
parser.Parse("CREATE TABLE bar(a int)");
parser.Parse("CREATE INDEX a ON dbo.foo(a)");
parser.Parse("CREATE INDEX a ON dbo.bar(a)");
Assert.AreEqual(2, parser.Database.Tables.Count);
Assert.AreEqual(1, parser.Database.Tables[0].Indexes.Count);
Assert.AreEqual(1, parser.Database.Tables[1].Indexes.Count);
ScriptSet scripts = parser.Database.CreateDiffScripts(new Database());
Assert.AreEqual(4, scripts.Count);
scripts.Sort();
Assert.AreEqual(ScriptType.Table, scripts[0].Type);
Assert.AreEqual(ScriptType.Table, scripts[1].Type);
Assert.AreEqual(ScriptType.Index, scripts[2].Type);
Assert.AreEqual(ScriptType.Index, scripts[3].Type);
ExecuteScripts(scripts);
ScriptParser database = ParseDatabase();
Assert.AreEqual(2, database.Database.Tables.Count);
Assert.AreEqual(1, database.Database.Tables[0].Indexes.Count);
Assert.AreEqual(1, database.Database.Tables[1].Indexes.Count);
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void TableFunctionViewTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse(@"CREATE TABLE dbo.foo(
fooID int identity(0, 1)
)");
startingDatabase.Parse("CREATE Function dbo.bar (@A int) RETURNS int AS BEGIN RETURN @A END");
startingDatabase.Parse(@"CREATE VIEW dbo.baz
AS
SELECT FooID,
dbo.bar(FooID) 'bonk'
FROM dbo.foo");
Assert.AreEqual(1, startingDatabase.Database.Functions.Count);
Assert.AreEqual(1, startingDatabase.Database.Tables.Count);
Assert.AreEqual(1, startingDatabase.Database.Views.Count);
//make sure this runs
ScriptParser currentDatabase = new ScriptParser();
ScriptSet scripts = startingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
ExecuteScripts(startingDatabase.Database.CreateDiffScripts(currentDatabase.Database));
//make sure it got results
currentDatabase = ParseDatabase();
ScriptSet difference = startingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void ViewNameChangeTest()
{
RunOptions.Current.FullyScripted = false;
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TABLE foo( a int)");
startingDatabase.Parse("CREATE View A AS SELECT * FROM foo");
ScriptParser currentDatabase = new ScriptParser();
ExecuteScripts(startingDatabase.Database.CreateDiffScripts(currentDatabase.Database));
ScriptParser endingDatabase = new ScriptParser();
endingDatabase.Parse("CREATE View B AS SELECT * FROM foo");
ScriptSet scripts = endingDatabase.Database.CreateDiffScripts(startingDatabase.Database);
Assert.AreEqual(1, scripts.Count);
Assert.AreEqual(scripts[0].Type, ScriptType.View);
ExecuteScripts(scripts);
currentDatabase = ParseDatabase();
ScriptSet difference = endingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void DefaultDataTest()
{
ScriptParser parsed = new ScriptParser();
parsed.Parse("CREATE TABLE foo( a varchar(10), b varchar(20) default 'foo')");
parsed.Parse(@"INSERT INTO foo(a) VALUES('X')
INSERT INTO foo(a, b) VALUES('A', 'B')");
ScriptSet scripts = parsed.Database.CreateDiffScripts(new Database());
scripts.Sort();
Assert.AreEqual(3, scripts.Count);
Assert.AreEqual(ScriptType.Table, scripts[0].Type);
Assert.AreEqual(ScriptType.DefaultConstraint, scripts[1].Type);
Assert.AreEqual(ScriptType.TableData, scripts[2].Type);
Assert.AreEqual(@"INSERT INTO [dbo].[foo]([a], [b])
VALUES('X', 'foo')
INSERT INTO [dbo].[foo]([a], [b])
VALUES('A', 'B')
",
scripts[2].Text);
scripts = parsed.Database.CreateDiffScripts(parsed.Database);
Assert.AreEqual(0, scripts.Count);
}
public void RenamePrimaryKeyTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TABLE foo( a int, b int)");
startingDatabase.Parse(@"ALTER TABLE foo
ADD CONSTRAINT PK_BADNAME
PRIMARY KEY CLUSTERED(a)");
startingDatabase.Parse("CREATE TABLE bar( c int FOREIGN KEY REFERENCES foo(a))");
ScriptSet scripts = startingDatabase.Database.CreateDiffScripts(new Database());
ExecuteScripts(scripts);
ScriptParser modifiedDatabase = new ScriptParser();
modifiedDatabase.Parse("CREATE TABLE foo( a int PRIMARY KEY, b int)");
modifiedDatabase.Parse("CREATE TABLE bar( c int FOREIGN KEY REFERENCES foo(a))");
scripts = modifiedDatabase.Database.CreateDiffScripts(startingDatabase.Database);
scripts.Sort();
Assert.AreEqual(4, scripts.Count);
Assert.AreEqual(ScriptType.DropForeignKey, scripts[0].Type);
Assert.AreEqual(ScriptType.DropPrimaryKey, scripts[1].Type);
Assert.AreEqual(ScriptType.PrimaryKey, scripts[2].Type);
Assert.AreEqual(ScriptType.ForeignKey, scripts[3].Type);
ExecuteScripts(scripts);
}
public void FulltextStoplistTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE FULLTEXT CATALOG Fulltext AS DEFAULT");
parser.Parse(@"CREATE TABLE Searching
(
SearchingID int NOT NULL,
SearchText varchar(max),
LastUpdate timestamp
)");
parser.Parse("CREATE UNIQUE CLUSTERED INDEX PK_Searching ON dbo.Searching(SearchingID)");
parser.Parse(@"CREATE FULLTEXT INDEX ON Searching(
SearchText LANGUAGE English
)
KEY INDEX PK_Searching ON Fulltext
WITH (CHANGE_TRACKING = AUTO, STOPLIST = OFF)");
Assert.AreEqual(1, parser.Database.Tables.Count);
Assert.AreEqual(1, parser.Database.Tables[0].Indexes.Count);
Assert.AreEqual(1, parser.Database.FulltextIndexes.Count);
ScriptSet scripts = parser.Database.CreateDiffScripts(new Database());
scripts.Sort();
Assert.AreEqual(4, scripts.Count);
Assert.AreEqual(ScriptType.Table, scripts[0].Type);
Assert.AreEqual(@"CREATE TABLE [dbo].[Searching](
[SearchingID] [int] NOT NULL,
[SearchText] [varchar](max) NULL,
[LastUpdate] [timestamp] NULL
)
GO", scripts[0].Text);
Assert.AreEqual(ScriptType.ClusteredIndex, scripts[1].Type);
Assert.AreEqual(@"CREATE UNIQUE CLUSTERED INDEX [PK_Searching]
ON [dbo].[Searching](
[SearchingID] ASC
)
", scripts[1].Text);
Assert.AreEqual(ScriptType.FulltextCatalog, scripts[2].Type);
Assert.AreEqual(ScriptType.FulltextIndex, scripts[3].Type);
Assert.AreEqual(@"CREATE FULLTEXT INDEX ON [dbo].[Searching](
[SearchText] LANGUAGE [English]
)
KEY INDEX [PK_Searching]
ON ([Fulltext])
WITH (CHANGE_TRACKING AUTO, STOPLIST OFF)", scripts[3].Text);
ExecuteScripts(scripts);
ScriptParser database = ParseDatabase();
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void AddDefaultTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TABLE foo( a int, b int)");
startingDatabase.Parse("INSERT INTO foo(a) VALUES(1)");
ScriptParser currentDatabase = new ScriptParser();
ExecuteScripts(startingDatabase.Database.CreateDiffScripts(currentDatabase.Database));
ScriptParser endingDatabase = new ScriptParser();
endingDatabase.Parse("CREATE TABLE foo( a int, b int NOT NULL DEFAULT(0))");
ScriptSet scripts = endingDatabase.Database.CreateDiffScripts(startingDatabase.Database);
scripts.Sort();
Assert.AreEqual(4, scripts.Count);
Assert.AreEqual(scripts[0].Type, ScriptType.TableSaveData);
Assert.AreEqual("EXEC sp_rename '[dbo].[foo]', 'Tmp__foo', 'OBJECT'", scripts[0].Text);
Assert.AreEqual(scripts[1].Type, ScriptType.Table);
//the actual script should be tested in the parser tests
Assert.AreEqual(scripts[2].Type, ScriptType.DefaultConstraint);
Assert.AreEqual(@"ALTER TABLE [dbo].[foo]
ADD CONSTRAINT [DF_foo_b]
DEFAULT ( 0 )
FOR [b]", scripts[2].Text);
Assert.AreEqual(scripts[3].Type, ScriptType.TableRestoreData);
Assert.AreEqual(@"INSERT INTO [dbo].[foo] (
[a],
[b]
)
SELECT
[a],
ISNULL([b], 0)
FROM [dbo].[Tmp__foo] WITH (HOLDLOCK TABLOCKX)
DROP TABLE [dbo].[Tmp__foo]
GO
", scripts[3].Text);
ExecuteScripts(scripts);
currentDatabase = ParseDatabase();
ScriptSet difference = endingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void DataTypesTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse(@"CREATE TABLE a(
b bigint,
c bit,
d char(1),
e datetime,
f decimal,
g float,
h int,
i money,
j ntext,
k nvarchar(max),
l smalldatetime,
m smallint,
n text,
o tinyint,
p varchar(max)
)");
parser.Parse(@"INSERT INTO a(b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) VALUES(
3333333333,
1,
'a',
'2000-01-02 03:04:05.600',
3,
3.14,
42,
3.14,
'lorem ipsum',
'lorem ipsum',
'1/2/2000',
42,
'lorem ipsum',
42,
'lorem ipsum'
)");
ScriptSet initScripts = parser.Database.CreateDiffScripts(new Database());
initScripts.Sort();
Assert.AreEqual(2, initScripts.Count);
Assert.AreEqual(ScriptType.Table, initScripts[0].Type);
Assert.AreEqual(ScriptType.TableData, initScripts[1].Type);
ExecuteScripts(initScripts);
ScriptParser currentDatabase = ParseDatabase();
GetData(currentDatabase.Database, parser.Database.GetTablesWithData());
ScriptSet difference = parser.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count);
}
public void DateTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE a( b int primary key, c datetime)");
parser.Parse("INSERT INTO a(b, c) VALUES(1, '2000-01-02 03:04:05.600')");
ScriptSet initScripts = parser.Database.CreateDiffScripts(new Database());
initScripts.Sort();
Assert.AreEqual(3, initScripts.Count);
Assert.AreEqual(ScriptType.Table, initScripts[0].Type);
Assert.AreEqual(ScriptType.PrimaryKey, initScripts[1].Type);
Assert.AreEqual(ScriptType.TableData, initScripts[2].Type);
Assert.AreEqual(@"INSERT INTO [dbo].[a]([b], [c])
VALUES(1, '2000-01-02 03:04:05.600')
", initScripts[2].Text);
ExecuteScripts(initScripts);
ScriptParser currentDatabase = ParseDatabase();
GetData(currentDatabase.Database, parser.Database.GetTablesWithData());
ScriptSet difference = parser.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count);
ScriptParser updated = new ScriptParser();
updated.Parse("CREATE TABLE a( b int primary key, c datetime)");
updated.Parse("INSERT INTO a(b, c) VALUES(1, '2000-01-02')");
difference = updated.Database.CreateDiffScripts(currentDatabase.Database);
difference.Sort();
Assert.AreEqual(2, difference.Count);
Assert.AreEqual(ScriptType.TableRemoveData, difference[0].Type);
Assert.AreEqual(@"DELETE FROM [dbo].[a]
WHERE
[b] = 1
AND [c] = '2000-01-02 03:04:05.600'
", difference[0].Text);
Assert.AreEqual(ScriptType.TableData, difference[1].Type);
Assert.AreEqual(@"INSERT INTO [dbo].[a]([b], [c])
VALUES(1, '2000-01-02 00:00:00.000')
", difference[1].Text);
ExecuteScripts(difference);
currentDatabase = ParseDatabase();
GetData(currentDatabase.Database, parser.Database.GetTablesWithData());
difference = updated.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count);
}
public void UpdateTableDataTest()
{
ScriptParser startingDatabase = new ScriptParser();
startingDatabase.Parse("CREATE TABLE foo( a int PRIMARY KEY, b int)");
startingDatabase.Parse("INSERT INTO foo(a) VALUES (1)");
startingDatabase.Parse("CREATE TABLE bar( c int FOREIGN KEY REFERENCES foo(a))");
startingDatabase.Parse("INSERT INTO bar(c) VALUES (1)");
ScriptParser currentDatabase = new ScriptParser();
ScriptSet scripts = startingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
ExecuteScripts(scripts);
currentDatabase = ParseDatabase();
GetData(currentDatabase.Database, startingDatabase.Database.GetTablesWithData());
ScriptSet difference = startingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
ScriptParser endingDatabase = new ScriptParser();
endingDatabase.Parse("CREATE TABLE foo( a int PRIMARY KEY, b int)");
endingDatabase.Parse("INSERT INTO foo(a, b) VALUES (1, 2)");
endingDatabase.Parse("CREATE TABLE bar( c int FOREIGN KEY REFERENCES foo(a))");
endingDatabase.Parse("INSERT INTO bar(c) VALUES (1)");
scripts = endingDatabase.Database.CreateDiffScripts(startingDatabase.Database);
scripts.Sort();
Assert.AreEqual(4, scripts.Count);
Assert.AreEqual(ScriptType.DropForeignKey, scripts[0].Type);
Assert.AreEqual(ScriptType.TableRemoveData, scripts[1].Type);
Assert.AreEqual(@"DELETE FROM [dbo].[foo]
WHERE
[a] = 1
", scripts[1].Text);
Assert.AreEqual(ScriptType.TableData, scripts[2].Type);
Assert.AreEqual(@"INSERT INTO [dbo].[foo]([a], [b])
VALUES(1, 2)
", scripts[2].Text);
Assert.AreEqual(ScriptType.ForeignKey, scripts[3].Type);
ExecuteScripts(scripts);
currentDatabase = ParseDatabase();
GetData(currentDatabase.Database, endingDatabase.Database.GetTablesWithData());
difference = endingDatabase.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void ForeignKeyTest()
{
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE foo(a int PRIMARY KEY)");
parser.Parse("CREATE TABLE bar(a int)");
parser.Parse(@"ALTER TABLE bar WITH CHECK
ADD CONSTRAINT FK_Bar_Foo_a
FOREIGN KEY( a )
REFERENCES foo(a)");
Assert.AreEqual(2, parser.Database.Tables.Count);
Assert.AreEqual(2, parser.Database.Constraints.Count);
ScriptSet scripts = parser.Database.CreateDiffScripts(new Database());
scripts.Sort();
Assert.AreEqual(4, scripts.Count);
Assert.AreEqual(@"CREATE TABLE [dbo].[bar](
[a] [int] NULL
)
GO", scripts[0].Text);
Assert.AreEqual(@"CREATE TABLE [dbo].[foo](
[a] [int] NOT NULL
)
GO", scripts[1].Text);
Assert.AreEqual(@"ALTER TABLE [dbo].[foo]
ADD CONSTRAINT [PK_foo]
PRIMARY KEY(
[a]
)", scripts[2].Text);
Assert.AreEqual(@"ALTER TABLE [dbo].[bar]
WITH CHECK
ADD CONSTRAINT [FK_Bar_Foo_a]
FOREIGN KEY(
[a]
)
REFERENCES [dbo].[foo](
[a]
)", scripts[3].Text);
ExecuteScripts(scripts);
ScriptParser database = ParseDatabase();
ScriptSet difference = parser.Database.CreateDiffScripts(database.Database);
Assert.AreEqual(0, difference.Count, RunOptions.Current.Logger.ToString());
}
public void ForeignKeyUniqueIndexNameChangeTest()
{
RunOptions.Current.FullyScripted = true;
//Set up the database
ScriptParser parser = new ScriptParser();
parser.Parse("CREATE TABLE base(a int)");
parser.Parse("CREATE TABLE dependant(a int foreign key references base(a))");
parser.Parse("CREATE UNIQUE NONCLUSTERED INDEX ix_base ON base(a)");
ScriptSet differences = parser.Database.CreateDiffScripts(new Database());
differences.Sort();
Assert.AreEqual(4, differences.Count);
Assert.AreEqual(ScriptType.Table, differences[0].Type);
Assert.AreEqual(ScriptType.Table, differences[1].Type);
Assert.AreEqual(ScriptType.Index, differences[2].Type);
Assert.AreEqual(ScriptType.ForeignKey, differences[3].Type);
//Make sure everything applies correctly
ExecuteScripts(differences);
ScriptParser currentDatabase = ParseDatabase();
differences = parser.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, differences.Count);
//Rename the unique constraint
parser = new ScriptParser();
parser.Parse("CREATE TABLE base(a int)");
parser.Parse("CREATE TABLE dependant(a int foreign key references base(a))");
parser.Parse("CREATE UNIQUE NONCLUSTERED INDEX ix_base_a ON base(a)");
differences = parser.Database.CreateDiffScripts(currentDatabase.Database);
differences.Sort();
Assert.AreEqual(4, differences.Count);
Assert.AreEqual(ScriptType.DropForeignKey, differences[0].Type);
Assert.AreEqual(ScriptType.DropIndex, differences[1].Type);
Assert.AreEqual(ScriptType.Index, differences[2].Type);
Assert.AreEqual(ScriptType.ForeignKey, differences[3].Type);
//Make sure everything applies correctly
ExecuteScripts(differences);
currentDatabase = ParseDatabase();
differences = parser.Database.CreateDiffScripts(currentDatabase.Database);
Assert.AreEqual(0, differences.Count);
}
/// <summary>
/// Formats the messages with the generated font by replacing the text with shift-jis characters.
/// </summary>
/// <param name="save"></param>
public void Format(bool save = true)
{
foreach (ScriptDocument script in Scripts)
{
if (script.BaseFile.GetType() != typeof(LZBFile))
{
continue;
}
List <IScriptElement> elements = ScriptParser.Parse(script);
foreach (IScriptElement element in elements)
{
if (element.GetType() == typeof(ScriptMessage))
{
ScriptMessage message = (ScriptMessage)element;
message.Format(this);
}
else if (element.GetType() == typeof(ScriptGmap))
{
ScriptGmap gmap = (ScriptGmap)element;
gmap.Format(this);
}
}
ScriptParser.Parse(script, elements);
if (save)
{
script.WriteToOriginalFile();
}
}
foreach (HardCodedText text in HardCodedTexts)
{
text.Format(this);
}
}
private void ParseScript()
{
this.m_Hints.Clear();
ScriptParser scriptParser = new ScriptParser();
scriptParser.Parse("Hints/Hints", true);
for (int i = 0; i < scriptParser.GetKeysCount(); i++)
{
Key key = scriptParser.GetKey(i);
if (key.GetName() == "Hint")
{
Hint hint = new Hint();
hint.m_Name = key.GetVariable(0).SValue;
hint.m_ShowNTimes = key.GetVariable(1).IValue;
for (int j = 0; j < key.GetKeysCount(); j++)
{
Key key2 = key.GetKey(j);
if (key2.GetName() == "Text")
{
hint.m_Text = key2.GetVariable(0).SValue;
hint.m_LocalizedText = GreenHellGame.Instance.GetLocalization().Get(hint.m_Text, true);
string key3 = GreenHellGame.Instance.GetLocalization().Contains(hint.m_Text + "Pad") ? (hint.m_Text + "Pad") : hint.m_Text;
hint.m_LocalizedPadText = GreenHellGame.Instance.GetLocalization().Get(key3, false);
}
else if (key2.GetName() == "Duration")
{
hint.m_Duration = key2.GetVariable(0).FValue;
}
}
this.m_Hints.Add(hint);
}
}
}
