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); } } }