5 | 6 |

7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /DbAccess/ColumnSchema.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | ///

8 | /// Contains the schema of a single DB column. 9 | ///

10 | public class ColumnSchema 11 | { 12 | public string ColumnName; 13 | 14 | public string ColumnType; 15 | 16 | public int Length; 17 | 18 | public bool IsNullable; 19 | 20 | public string DefaultValue; 21 | 22 | public bool IsIdentity; 23 | 24 | public bool? IsCaseSensitivite = null; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /DbAccess/DatabaseSchema.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | ///

8 | /// Contains the entire database schema 9 | ///

10 | public class DatabaseSchema 11 | { 12 | public List Tables = new List(); 13 | public List Views = new List(); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /DbAccess/DbAccess.csproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Debug 5 | AnyCPU 6 | 8.0.50727 7 | 2.0 8 | {23AAF1EF-2EB6-43AD-8103-A687F04A7288} 9 | Library 10 | Properties 11 | DbAccess 12 | DbAccess 13 | v2.0 14 | 15 | 16 | 2.0 17 | 18 | publish\ 19 | true 20 | Disk 21 | false 22 | Foreground 23 | 7 24 | Days 25 | false 26 | false 27 | true 28 | 0 29 | 1.0.0.%2a 30 | false 31 | false 32 | true 33 | 34 | 35 | true 36 | full 37 | false 38 | bin\Debug\ 39 | DEBUG;TRACE 40 | prompt 41 | 4 42 | x86 43 | AllRules.ruleset 44 | 45 | 46 | pdbonly 47 | true 48 | bin\Release\ 49 | TRACE 50 | prompt 51 | 4 52 | AllRules.ruleset 53 | 54 | 55 | 56 | False 57 | ..\log4net.dll 58 | 59 | 60 | 61 | 62 | False 63 | ..\System.Data.SQLite.dll 64 | 65 | 66 | 67 | 68 | 69 | Properties\SolutionInfo.cs 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | False 84 | .NET Framework 3.5 SP1 Client Profile 85 | false 86 | 87 | 88 | False 89 | .NET Framework 3.5 SP1 90 | true 91 | 92 | 93 | False 94 | Windows Installer 3.1 95 | true 96 | 97 | 98 | 99 | 106 | 107 | 108 | 109 | 110 | 111 | -------------------------------------------------------------------------------- /DbAccess/ForeignKeySchema.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | public class ForeignKeySchema 8 | { 9 | public string TableName; 10 | 11 | public string ColumnName; 12 | 13 | public string ForeignTableName; 14 | 15 | public string ForeignColumnName; 16 | 17 | public bool CascadeOnDelete; 18 | 19 | public bool IsNullable; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /DbAccess/IndexSchema.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | public class IndexSchema 8 | { 9 | public string IndexName; 10 | 11 | public bool IsUnique; 12 | 13 | public List Columns; 14 | } 15 | 16 | public class IndexColumn 17 | { 18 | public string ColumnName; 19 | public bool IsAscending; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /DbAccess/SqlServerToSQLite.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | using System.Data; 5 | using System.Data.SqlClient; 6 | using System.Data.SQLite; 7 | using System.Threading; 8 | using System.Text.RegularExpressions; 9 | using System.IO; 10 | using log4net; 11 | 12 | namespace DbAccess 13 | { 14 | ///

15 | /// This class is resposible to take a single SQL Server database 16 | /// and convert it to an SQLite database file. 17 | ///

18 | /// The class knows how to convert table and index structures only. 19 | public class SqlServerToSQLite 20 | { 21 | #region Public Properties 22 | ///

23 | /// Gets a value indicating whether this instance is active. 24 | ///

25 | /// true if this instance is active; otherwise, false. 26 | public static bool IsActive 27 | { 28 | get { return _isActive; } 29 | } 30 | #endregion 31 | 32 | #region Public Methods 33 | ///

34 | /// Cancels the conversion. 35 | ///

36 | public static void CancelConversion() 37 | { 38 | _cancelled = true; 39 | } 40 | 41 | ///

42 | /// This method takes as input the connection string to an SQL Server database 43 | /// and creates a corresponding SQLite database file with a schema derived from 44 | /// the SQL Server database. 45 | ///

46 | /// The connection string to the SQL Server database. 47 | /// The path to the SQLite database file that needs to get created. 48 | /// The password to use or NULL if no password should be used to encrypt the DB 49 | /// A handler delegate for progress notifications. 50 | /// The selection handler that allows the user to select which 51 | /// tables to convert 52 | /// The method continues asynchronously in the background and the caller returned 53 | /// immediatly. 54 | public static void ConvertSqlServerToSQLiteDatabase(string sqlServerConnString, 55 | string sqlitePath, string password, SqlConversionHandler handler, 56 | SqlTableSelectionHandler selectionHandler, 57 | FailedViewDefinitionHandler viewFailureHandler, 58 | bool createTriggers) 59 | { 60 | // Clear cancelled flag 61 | _cancelled = false; 62 | 63 | WaitCallback wc = new WaitCallback(delegate(object state) 64 | { 65 | try 66 | { 67 | _isActive = true; 68 | ConvertSqlServerDatabaseToSQLiteFile(sqlServerConnString, sqlitePath, password, handler, selectionHandler, viewFailureHandler, createTriggers); 69 | _isActive = false; 70 | handler(true, true, 100, "Finished converting database"); 71 | } 72 | catch (Exception ex) 73 | { 74 | _log.Error("Failed to convert SQL Server database to SQLite database", ex); 75 | _isActive = false; 76 | handler(true, false, 100, ex.Message); 77 | } // catch 78 | }); 79 | ThreadPool.QueueUserWorkItem(wc); 80 | } 81 | #endregion 82 | 83 | #region Private Methods 84 | ///

85 | /// Do the entire process of first reading the SQL Server schema, creating a corresponding 86 | /// SQLite schema, and copying all rows from the SQL Server database to the SQLite database. 87 | ///

88 | /// The SQL Server connection string 89 | /// The path to the generated SQLite database file 90 | /// The password to use or NULL if no password should be used to encrypt the DB 91 | /// A handler to handle progress notifications. 92 | /// The selection handler which allows the user to select which tables to 93 | /// convert. 94 | private static void ConvertSqlServerDatabaseToSQLiteFile( 95 | string sqlConnString, string sqlitePath, string password, SqlConversionHandler handler, 96 | SqlTableSelectionHandler selectionHandler, 97 | FailedViewDefinitionHandler viewFailureHandler, 98 | bool createTriggers) 99 | { 100 | // Delete the target file if it exists already. 101 | if (File.Exists(sqlitePath)) 102 | File.Delete(sqlitePath); 103 | 104 | // Read the schema of the SQL Server database into a memory structure 105 | DatabaseSchema ds = ReadSqlServerSchema(sqlConnString, handler, selectionHandler); 106 | 107 | // Create the SQLite database and apply the schema 108 | CreateSQLiteDatabase(sqlitePath, ds, password, handler, viewFailureHandler); 109 | 110 | // Copy all rows from SQL Server tables to the newly created SQLite database 111 | CopySqlServerRowsToSQLiteDB(sqlConnString, sqlitePath, ds.Tables, password, handler); 112 | 113 | // Add triggers based on foreign key constraints 114 | if (createTriggers) 115 | AddTriggersForForeignKeys(sqlitePath, ds.Tables, password, handler); 116 | 117 | } 118 | 119 | ///

120 | /// Copies table rows from the SQL Server database to the SQLite database. 121 | ///

122 | /// The SQL Server connection string 123 | /// The path to the SQLite database file. 124 | /// The schema of the SQL Server database. 125 | /// The password to use for encrypting the file 126 | /// A handler to handle progress notifications. 127 | private static void CopySqlServerRowsToSQLiteDB( 128 | string sqlConnString, string sqlitePath, List schema, 129 | string password, SqlConversionHandler handler) 130 | { 131 | CheckCancelled(); 132 | handler(false, true, 0, "Preparing to insert tables..."); 133 | _log.Debug("preparing to insert tables ..."); 134 | 135 | // Connect to the SQL Server database 136 | using (SqlConnection ssconn = new SqlConnection(sqlConnString)) 137 | { 138 | ssconn.Open(); 139 | 140 | // Connect to the SQLite database next 141 | string sqliteConnString = CreateSQLiteConnectionString(sqlitePath, password); 142 | using (SQLiteConnection sqconn = new SQLiteConnection(sqliteConnString)) 143 | { 144 | sqconn.Open(); 145 | 146 | // Go over all tables in the schema and copy their rows 147 | for (int i = 0; i < schema.Count; i++) 148 | { 149 | SQLiteTransaction tx = sqconn.BeginTransaction(); 150 | try 151 | { 152 | string tableQuery = BuildSqlServerTableQuery(schema[i]); 153 | SqlCommand query = new SqlCommand(tableQuery, ssconn); 154 | using (SqlDataReader reader = query.ExecuteReader()) 155 | { 156 | SQLiteCommand insert = BuildSQLiteInsert(schema[i]); 157 | int counter = 0; 158 | while (reader.Read()) 159 | { 160 | insert.Connection = sqconn; 161 | insert.Transaction = tx; 162 | List pnames = new List(); 163 | for (int j = 0; j < schema[i].Columns.Count; j++) 164 | { 165 | string pname = "@" + GetNormalizedName(schema[i].Columns[j].ColumnName, pnames); 166 | insert.Parameters[pname].Value = CastValueForColumn(reader[j], schema[i].Columns[j]); 167 | pnames.Add(pname); 168 | } 169 | insert.ExecuteNonQuery(); 170 | counter++; 171 | if (counter % 1000 == 0) 172 | { 173 | CheckCancelled(); 174 | tx.Commit(); 175 | handler(false, true, (int)(100.0 * i / schema.Count), 176 | "Added " + counter + " rows to table "+schema[i].TableName+" so far"); 177 | tx = sqconn.BeginTransaction(); 178 | } 179 | } // while 180 | } // using 181 | 182 | CheckCancelled(); 183 | tx.Commit(); 184 | 185 | handler(false, true, (int)(100.0 * i / schema.Count), "Finished inserting rows for table " + schema[i].TableName); 186 | _log.Debug("finished inserting all rows for table [" + schema[i].TableName + "]"); 187 | } 188 | catch (Exception ex) 189 | { 190 | _log.Error("unexpected exception", ex); 191 | tx.Rollback(); 192 | throw; 193 | } // catch 194 | } 195 | } // using 196 | } // using 197 | } 198 | 199 | ///

200 | /// Used in order to adjust the value received from SQL Servr for the SQLite database. 201 | ///

202 | /// The value object 203 | /// The corresponding column schema 204 | /// SQLite adjusted value. 205 | private static object CastValueForColumn(object val, ColumnSchema columnSchema) 206 | { 207 | if (val is DBNull) 208 | return null; 209 | 210 | DbType dt = GetDbTypeOfColumn(columnSchema); 211 | 212 | switch (dt) 213 | { 214 | case DbType.Int32: 215 | if (val is short) 216 | return (int)(short)val; 217 | if (val is byte) 218 | return (int)(byte)val; 219 | if (val is long) 220 | return (int)(long)val; 221 | if (val is decimal) 222 | return (int)(decimal)val; 223 | break; 224 | 225 | case DbType.Int16: 226 | if (val is int) 227 | return (short)(int)val; 228 | if (val is byte) 229 | return (short)(byte)val; 230 | if (val is long) 231 | return (short)(long)val; 232 | if (val is decimal) 233 | return (short)(decimal)val; 234 | break; 235 | 236 | case DbType.Int64: 237 | if (val is int) 238 | return (long)(int)val; 239 | if (val is short) 240 | return (long)(short)val; 241 | if (val is byte) 242 | return (long)(byte)val; 243 | if (val is decimal) 244 | return (long)(decimal)val; 245 | break; 246 | 247 | case DbType.Single: 248 | if (val is double) 249 | return (float)(double)val; 250 | if (val is decimal) 251 | return (float)(decimal)val; 252 | break; 253 | 254 | case DbType.Double: 255 | if (val is float) 256 | return (double)(float)val; 257 | if (val is double) 258 | return (double)val; 259 | if (val is decimal) 260 | return (double)(decimal)val; 261 | break; 262 | 263 | case DbType.String: 264 | if (val is Guid) 265 | return ((Guid)val).ToString(); 266 | break; 267 | 268 | case DbType.Guid: 269 | if (val is string) 270 | return ParseStringAsGuid((string)val); 271 | if (val is byte[]) 272 | return ParseBlobAsGuid((byte[])val); 273 | break; 274 | 275 | case DbType.Time: 276 | case DbType.DateTime: 277 | case DbType.Date: 278 | case DbType.DateTime2: 279 | if (val is TimeSpan) 280 | return DateTime.MinValue + (TimeSpan)val; 281 | break; 282 | case DbType.Binary: 283 | case DbType.Boolean: 284 | break; 285 | 286 | default: 287 | _log.Error("argument exception - illegal database type"); 288 | throw new ArgumentException("Illegal database type [" + Enum.GetName(typeof(DbType), dt) + "]"); 289 | } // switch 290 | 291 | return val; 292 | } 293 | 294 | private static Guid ParseBlobAsGuid(byte[] blob) 295 | { 296 | byte[] data = blob; 297 | if (blob.Length > 16) 298 | { 299 | data = new byte[16]; 300 | for (int i = 0; i < 16; i++) 301 | data[i] = blob[i]; 302 | } 303 | else if (blob.Length < 16) 304 | { 305 | data = new byte[16]; 306 | for (int i = 0; i < blob.Length; i++) 307 | data[i] = blob[i]; 308 | } 309 | 310 | return new Guid(data); 311 | } 312 | 313 | private static Guid ParseStringAsGuid(string str) 314 | { 315 | try 316 | { 317 | return new Guid(str); 318 | } 319 | catch (Exception ex) 320 | { 321 | return Guid.Empty; 322 | } // catch 323 | } 324 | 325 | ///

326 | /// Creates a command object needed to insert values into a specific SQLite table. 327 | ///

328 | /// The table schema object for the table. 329 | /// A command object with the required functionality. 330 | private static SQLiteCommand BuildSQLiteInsert(TableSchema ts) 331 | { 332 | SQLiteCommand res = new SQLiteCommand(); 333 | 334 | StringBuilder sb = new StringBuilder(); 335 | sb.Append("INSERT INTO [" + ts.TableName + "] ("); 336 | for (int i = 0; i < ts.Columns.Count; i++) 337 | { 338 | sb.Append("[" + ts.Columns[i].ColumnName + "]"); 339 | if (i < ts.Columns.Count - 1) 340 | sb.Append(", "); 341 | } // for 342 | sb.Append(") VALUES ("); 343 | 344 | List pnames = new List(); 345 | for (int i = 0; i < ts.Columns.Count; i++) 346 | { 347 | string pname = "@" + GetNormalizedName(ts.Columns[i].ColumnName, pnames); 348 | sb.Append(pname); 349 | if (i < ts.Columns.Count - 1) 350 | sb.Append(", "); 351 | 352 | DbType dbType = GetDbTypeOfColumn(ts.Columns[i]); 353 | SQLiteParameter prm = new SQLiteParameter(pname, dbType, ts.Columns[i].ColumnName); 354 | res.Parameters.Add(prm); 355 | 356 | // Remember the parameter name in order to avoid duplicates 357 | pnames.Add(pname); 358 | } // for 359 | sb.Append(")"); 360 | res.CommandText = sb.ToString(); 361 | res.CommandType = CommandType.Text; 362 | return res; 363 | } 364 | 365 | ///

366 | /// Used in order to avoid breaking naming rules (e.g., when a table has 367 | /// a name in SQL Server that cannot be used as a basis for a matching index 368 | /// name in SQLite). 369 | ///

370 | /// The name to change if necessary 371 | /// Used to avoid duplicate names 372 | /// A normalized name 373 | private static string GetNormalizedName(string str, List names) 374 | { 375 | StringBuilder sb = new StringBuilder(); 376 | for (int i = 0; i < str.Length; i++) 377 | { 378 | if (Char.IsLetterOrDigit(str[i]) || str[i] == '_') 379 | sb.Append(str[i]); 380 | else 381 | sb.Append("_"); 382 | } // for 383 | 384 | // Avoid returning duplicate name 385 | if (names.Contains(sb.ToString())) 386 | return GetNormalizedName(sb.ToString() + "_", names); 387 | else 388 | return sb.ToString(); 389 | } 390 | 391 | ///

392 | /// Matches SQL Server types to general DB types 393 | ///

394 | /// The column schema to use for the match 395 | /// The matched DB type 396 | private static DbType GetDbTypeOfColumn(ColumnSchema cs) 397 | { 398 | if (cs.ColumnType == "tinyint") 399 | return DbType.Byte; 400 | if (cs.ColumnType == "int") 401 | return DbType.Int32; 402 | if (cs.ColumnType == "smallint") 403 | return DbType.Int16; 404 | if (cs.ColumnType == "bigint") 405 | return DbType.Int64; 406 | if (cs.ColumnType == "bit") 407 | return DbType.Boolean; 408 | if (cs.ColumnType == "nvarchar" || cs.ColumnType == "varchar" || 409 | cs.ColumnType == "text" || cs.ColumnType == "ntext") 410 | return DbType.String; 411 | if (cs.ColumnType == "float") 412 | return DbType.Double; 413 | if (cs.ColumnType == "real") 414 | return DbType.Single; 415 | if (cs.ColumnType == "blob") 416 | return DbType.Binary; 417 | if (cs.ColumnType == "numeric") 418 | return DbType.Double; 419 | if (cs.ColumnType == "timestamp" || cs.ColumnType == "datetime") 420 | return DbType.DateTime; 421 | if (cs.ColumnType == "date") 422 | return DbType.Date; 423 | if (cs.ColumnType == "datetime2") 424 | return DbType.DateTime2; 425 | if (cs.ColumnType == "nchar" || cs.ColumnType == "char") 426 | return DbType.String; 427 | if (cs.ColumnType == "uniqueidentifier" || cs.ColumnType == "guid") 428 | return DbType.Guid; 429 | if (cs.ColumnType == "xml") 430 | return DbType.String; 431 | if (cs.ColumnType == "sql_variant") 432 | return DbType.Object; 433 | if (cs.ColumnType == "integer") 434 | return DbType.Int64; 435 | if (cs.ColumnType == "time") 436 | return DbType.Time; 437 | 438 | _log.Error("illegal db type found"); 439 | throw new ApplicationException("Illegal DB type found (" + cs.ColumnType + ")"); 440 | } 441 | 442 | ///

443 | /// Builds a SELECT query for a specific table. Needed in the process of copying rows 444 | /// from the SQL Server database to the SQLite database. 445 | ///

446 | /// The table schema of the table for which we need the query. 447 | /// The SELECT query for the table. 448 | private static string BuildSqlServerTableQuery(TableSchema ts) 449 | { 450 | StringBuilder sb = new StringBuilder(); 451 | sb.Append("SELECT "); 452 | for (int i = 0; i < ts.Columns.Count; i++) 453 | { 454 | sb.Append("[" + ts.Columns[i].ColumnName + "]"); 455 | if (i < ts.Columns.Count - 1) 456 | sb.Append(", "); 457 | } // for 458 | sb.Append(" FROM "+ts.TableSchemaName+"."+"["+ts.TableName + "]"); 459 | return sb.ToString(); 460 | } 461 | 462 | ///

463 | /// Creates the SQLite database from the schema read from the SQL Server. 464 | ///

465 | /// The path to the generated DB file. 466 | /// The schema of the SQL server database. 467 | /// The password to use for encrypting the DB or null if non is needed. 468 | /// A handle for progress notifications. 469 | private static void CreateSQLiteDatabase(string sqlitePath, DatabaseSchema schema, string password, 470 | SqlConversionHandler handler, 471 | FailedViewDefinitionHandler viewFailureHandler) 472 | { 473 | _log.Debug("Creating SQLite database..."); 474 | 475 | // Create the SQLite database file 476 | SQLiteConnection.CreateFile(sqlitePath); 477 | 478 | _log.Debug("SQLite file was created successfully at [" + sqlitePath + "]"); 479 | 480 | // Connect to the newly created database 481 | string sqliteConnString = CreateSQLiteConnectionString(sqlitePath, password); 482 | using (SQLiteConnection conn = new SQLiteConnection(sqliteConnString)) 483 | { 484 | conn.Open(); 485 | 486 | // Create all tables in the new database 487 | int count = 0; 488 | foreach (TableSchema dt in schema.Tables) 489 | { 490 | try 491 | { 492 | AddSQLiteTable(conn, dt); 493 | } 494 | catch (Exception ex) 495 | { 496 | _log.Error("AddSQLiteTable failed", ex); 497 | throw; 498 | } 499 | count++; 500 | CheckCancelled(); 501 | handler(false, true, (int)(count * 50.0 / schema.Tables.Count), "Added table " + dt.TableName + " to the SQLite database"); 502 | 503 | _log.Debug("added schema for SQLite table [" + dt.TableName + "]"); 504 | } // foreach 505 | 506 | // Create all views in the new database 507 | count = 0; 508 | foreach (ViewSchema vs in schema.Views) 509 | { 510 | try 511 | { 512 | AddSQLiteView(conn, vs, viewFailureHandler); 513 | } 514 | catch (Exception ex) 515 | { 516 | _log.Error("AddSQLiteView failed", ex); 517 | throw; 518 | } // catch 519 | count++; 520 | CheckCancelled(); 521 | handler(false, true, 50+(int)(count * 50.0 / schema.Views.Count), "Added view " + vs.ViewName + " to the SQLite database"); 522 | 523 | _log.Debug("added schema for SQLite view [" + vs.ViewName + "]"); 524 | 525 | } // foreach 526 | } // using 527 | 528 | _log.Debug("finished adding all table/view schemas for SQLite database"); 529 | } 530 | 531 | private static void AddSQLiteView(SQLiteConnection conn, ViewSchema vs, FailedViewDefinitionHandler handler) 532 | { 533 | // Prepare a CREATE VIEW DDL statement 534 | string stmt = vs.ViewSQL; 535 | _log.Info("\n\n" + stmt + "\n\n"); 536 | 537 | // Execute the query in order to actually create the view. 538 | SQLiteTransaction tx = conn.BeginTransaction(); 539 | try 540 | { 541 | SQLiteCommand cmd = new SQLiteCommand(stmt, conn, tx); 542 | cmd.ExecuteNonQuery(); 543 | 544 | tx.Commit(); 545 | } 546 | catch (SQLiteException ex) 547 | { 548 | tx.Rollback(); 549 | 550 | if (handler != null) 551 | { 552 | ViewSchema updated = new ViewSchema(); 553 | updated.ViewName = vs.ViewName; 554 | updated.ViewSQL = vs.ViewSQL; 555 | 556 | // Ask the user to supply the new view definition SQL statement 557 | string sql = handler(updated); 558 | 559 | if (sql == null) 560 | return; // Discard the view 561 | else 562 | { 563 | // Try to re-create the view with the user-supplied view definition SQL 564 | updated.ViewSQL = sql; 565 | AddSQLiteView(conn, updated, handler); 566 | } 567 | } 568 | else 569 | throw; 570 | } // catch 571 | } 572 | 573 | ///

574 | /// Creates the CREATE TABLE DDL for SQLite and a specific table. 575 | ///

576 | /// The SQLite connection 577 | /// The table schema object for the table to be generated. 578 | private static void AddSQLiteTable(SQLiteConnection conn, TableSchema dt) 579 | { 580 | // Prepare a CREATE TABLE DDL statement 581 | string stmt = BuildCreateTableQuery(dt); 582 | 583 | _log.Info("\n\n" + stmt + "\n\n"); 584 | 585 | // Execute the query in order to actually create the table. 586 | SQLiteCommand cmd = new SQLiteCommand(stmt, conn); 587 | cmd.ExecuteNonQuery(); 588 | } 589 | 590 | ///

591 | /// returns the CREATE TABLE DDL for creating the SQLite table from the specified 592 | /// table schema object. 593 | ///

594 | /// The table schema object from which to create the SQL statement. 595 | /// CREATE TABLE DDL for the specified table. 596 | private static string BuildCreateTableQuery(TableSchema ts) 597 | { 598 | StringBuilder sb = new StringBuilder(); 599 | 600 | sb.Append("CREATE TABLE [" + ts.TableName + "] (\n"); 601 | 602 | bool pkey = false; 603 | for(int i=0; i 0 & !pkey) 614 | { 615 | sb.Append(",\n"); 616 | sb.Append(" PRIMARY KEY ("); 617 | for (int i = 0; i < ts.PrimaryKey.Count; i++) 618 | { 619 | sb.Append("["+ts.PrimaryKey[i]+"]"); 620 | if (i < ts.PrimaryKey.Count - 1) 621 | sb.Append(", "); 622 | } // for 623 | sb.Append(")\n"); 624 | } 625 | else 626 | sb.Append("\n"); 627 | 628 | // add foreign keys... 629 | if (ts.ForeignKeys.Count > 0) 630 | { 631 | sb.Append(",\n"); 632 | for (int i = 0; i < ts.ForeignKeys.Count; i++) 633 | { 634 | ForeignKeySchema foreignKey = ts.ForeignKeys[i]; 635 | string stmt = string.Format(" FOREIGN KEY ([{0}])\n REFERENCES [{1}]([{2}])", 636 | foreignKey.ColumnName, foreignKey.ForeignTableName, foreignKey.ForeignColumnName); 637 | 638 | sb.Append(stmt); 639 | if (i < ts.ForeignKeys.Count - 1) 640 | sb.Append(",\n"); 641 | } // for 642 | } 643 | 644 | sb.Append("\n"); 645 | sb.Append(");\n"); 646 | 647 | // Create any relevant indexes 648 | if (ts.Indexes != null) 649 | { 650 | for (int i = 0; i < ts.Indexes.Count; i++) 651 | { 652 | string stmt = BuildCreateIndex(ts.TableName, ts.Indexes[i]); 653 | sb.Append(stmt + ";\n"); 654 | } // for 655 | } // if 656 | 657 | string query = sb.ToString(); 658 | return query; 659 | } 660 | 661 | ///

662 | /// Creates a CREATE INDEX DDL for the specified table and index schema. 663 | ///

664 | /// The name of the indexed table. 665 | /// The schema of the index object 666 | /// A CREATE INDEX DDL (SQLite format). 667 | private static string BuildCreateIndex(string tableName, IndexSchema indexSchema) 668 | { 669 | StringBuilder sb = new StringBuilder(); 670 | sb.Append("CREATE "); 671 | if (indexSchema.IsUnique) 672 | sb.Append("UNIQUE "); 673 | sb.Append("INDEX [" + tableName+"_"+indexSchema.IndexName + "]\n"); 674 | sb.Append("ON [" + tableName+"]\n"); 675 | sb.Append("("); 676 | for (int i = 0; i < indexSchema.Columns.Count; i++) 677 | { 678 | sb.Append("["+indexSchema.Columns[i].ColumnName+"]"); 679 | if (!indexSchema.Columns[i].IsAscending) 680 | sb.Append(" DESC"); 681 | if (i < indexSchema.Columns.Count - 1) 682 | sb.Append(", "); 683 | } // for 684 | sb.Append(")"); 685 | 686 | return sb.ToString(); 687 | } 688 | 689 | ///

690 | /// Used when creating the CREATE TABLE DDL. Creates a single row 691 | /// for the specified column. 692 | ///

693 | /// The column schema 694 | /// A single column line to be inserted into the general CREATE TABLE DDL statement 695 | private static string BuildColumnStatement(ColumnSchema col, TableSchema ts, ref bool pkey) 696 | { 697 | StringBuilder sb = new StringBuilder(); 698 | sb.Append("\t\""+col.ColumnName + "\"\t\t"); 699 | 700 | // Special treatment for IDENTITY columns 701 | if (col.IsIdentity) 702 | { 703 | if (ts.PrimaryKey.Count == 1 && (col.ColumnType == "tinyint" || col.ColumnType == "int" || col.ColumnType == "smallint" || 704 | col.ColumnType == "bigint" || col.ColumnType == "integer")) 705 | { 706 | sb.Append("integer PRIMARY KEY AUTOINCREMENT"); 707 | pkey = true; 708 | } 709 | else 710 | sb.Append("integer"); 711 | } 712 | else 713 | { 714 | if (col.ColumnType == "int") 715 | sb.Append("integer"); 716 | else 717 | { 718 | sb.Append(col.ColumnType); 719 | } 720 | if (col.Length > 0) 721 | sb.Append("(" + col.Length + ")"); 722 | } 723 | if (!col.IsNullable) 724 | sb.Append(" NOT NULL"); 725 | 726 | if (col.IsCaseSensitivite.HasValue && !col.IsCaseSensitivite.Value) 727 | sb.Append(" COLLATE NOCASE"); 728 | 729 | string defval = StripParens(col.DefaultValue); 730 | defval = DiscardNational(defval); 731 | _log.Debug("DEFAULT VALUE BEFORE [" + col.DefaultValue + "] AFTER [" + defval + "]"); 732 | if (defval != string.Empty && defval.ToUpper().Contains("GETDATE")) 733 | { 734 | _log.Debug("converted SQL Server GETDATE() to CURRENT_TIMESTAMP for column ["+col.ColumnName+"]"); 735 | sb.Append(" DEFAULT (CURRENT_TIMESTAMP)"); 736 | } 737 | else if (defval != string.Empty && IsValidDefaultValue(defval)) 738 | sb.Append(" DEFAULT " + defval); 739 | 740 | return sb.ToString(); 741 | } 742 | 743 | ///

744 | /// Discards the national prefix if exists (e.g., N'sometext') which is not 745 | /// supported in SQLite. 746 | ///

747 | /// The value. 748 | /// 749 | private static string DiscardNational(string value) 750 | { 751 | Regex rx = new Regex(@"N\'([^\']*)\'"); 752 | Match m = rx.Match(value); 753 | if (m.Success) 754 | return m.Groups[1].Value; 755 | else 756 | return value; 757 | } 758 | 759 | ///

760 | /// Check if the DEFAULT clause is valid by SQLite standards 761 | ///

762 | /// 763 | /// 764 | private static bool IsValidDefaultValue(string value) 765 | { 766 | if (IsSingleQuoted(value)) 767 | return true; 768 | 769 | double testnum; 770 | if (!double.TryParse(value, out testnum)) 771 | return false; 772 | return true; 773 | } 774 | 775 | private static bool IsSingleQuoted(string value) 776 | { 777 | value = value.Trim(); 778 | if (value.StartsWith("'") && value.EndsWith("'")) 779 | return true; 780 | return false; 781 | } 782 | 783 | ///

784 | /// Strip any parentheses from the string. 785 | ///

786 | /// The string to strip 787 | /// The stripped string 788 | private static string StripParens(string value) 789 | { 790 | Regex rx = new Regex(@"\(([^\)]*)\)"); 791 | Match m = rx.Match(value); 792 | if (!m.Success) 793 | return value; 794 | else 795 | return StripParens(m.Groups[1].Value); 796 | } 797 | 798 | ///

799 | /// Reads the entire SQL Server DB schema using the specified connection string. 800 | ///

801 | /// The connection string used for reading SQL Server schema. 802 | /// A handler for progress notifications. 803 | /// The selection handler which allows the user to select 804 | /// which tables to convert. 805 | /// database schema objects for every table/view in the SQL Server database. 806 | private static DatabaseSchema ReadSqlServerSchema(string connString, SqlConversionHandler handler, 807 | SqlTableSelectionHandler selectionHandler) 808 | { 809 | // First step is to read the names of all tables in the database 810 | List tables = new List(); 811 | using (SqlConnection conn = new SqlConnection(connString)) 812 | { 813 | conn.Open(); 814 | 815 | List tableNames = new List(); 816 | List tblschema = new List(); 817 | 818 | // This command will read the names of all tables in the database 819 | SqlCommand cmd = new SqlCommand(@"select * from INFORMATION_SCHEMA.TABLES where TABLE_TYPE = 'BASE TABLE'", conn); 820 | using (SqlDataReader reader = cmd.ExecuteReader()) 821 | { 822 | while (reader.Read()) 823 | { 824 | tableNames.Add((string)reader["TABLE_NAME"]); 825 | tblschema.Add((string)reader["TABLE_SCHEMA"]); 826 | } // while 827 | } // using 828 | 829 | // Next step is to use ADO APIs to query the schema of each table. 830 | int count = 0; 831 | for (int i=0; i updated = selectionHandler(tables); 852 | if (updated != null) 853 | tables = updated; 854 | } // if 855 | 856 | Regex removedbo = new Regex(@"dbo\.", RegexOptions.Compiled | RegexOptions.IgnoreCase); 857 | 858 | // Continue and read all of the views in the database 859 | List views = new List(); 860 | using (SqlConnection conn = new SqlConnection(connString)) 861 | { 862 | conn.Open(); 863 | 864 | SqlCommand cmd = new SqlCommand(@"SELECT TABLE_NAME, VIEW_DEFINITION from INFORMATION_SCHEMA.VIEWS", conn); 865 | using (SqlDataReader reader = cmd.ExecuteReader()) 866 | { 867 | int count = 0; 868 | while (reader.Read()) 869 | { 870 | ViewSchema vs = new ViewSchema(); 871 | vs.ViewName = (string)reader["TABLE_NAME"]; 872 | vs.ViewSQL = reader["VIEW_DEFINITION"] as string ?? ""; 873 | 874 | // Remove all ".dbo" strings from the view definition 875 | vs.ViewSQL = removedbo.Replace(vs.ViewSQL, string.Empty); 876 | 877 | views.Add(vs); 878 | 879 | count++; 880 | CheckCancelled(); 881 | handler(false, true, 50+(int)(count * 50.0 / views.Count), "Parsed view " + vs.ViewName); 882 | 883 | _log.Debug("parsed view schema for [" + vs.ViewName + "]"); 884 | } // while 885 | } // using 886 | 887 | } // using 888 | 889 | DatabaseSchema ds = new DatabaseSchema(); 890 | ds.Tables = tables; 891 | ds.Views = views; 892 | return ds; 893 | } 894 | 895 | ///

896 | /// Convenience method for checking if the conversion progress needs to be cancelled. 897 | ///

898 | private static void CheckCancelled() 899 | { 900 | if (_cancelled) 901 | throw new ApplicationException("User cancelled the conversion"); 902 | } 903 | 904 | ///

905 | /// Creates a TableSchema object using the specified SQL Server connection 906 | /// and the name of the table for which we need to create the schema. 907 | ///

908 | /// The SQL Server connection to use 909 | /// The name of the table for which we wants to create the table schema. 910 | /// A table schema object that represents our knowledge of the table schema 911 | private static TableSchema CreateTableSchema(SqlConnection conn, string tableName, string tschma) 912 | { 913 | TableSchema res = new TableSchema(); 914 | res.TableName = tableName; 915 | res.TableSchemaName = tschma; 916 | res.Columns = new List(); 917 | SqlCommand cmd = new SqlCommand(@"SELECT COLUMN_NAME,COLUMN_DEFAULT,IS_NULLABLE,DATA_TYPE, " + 918 | @" (columnproperty(object_id(TABLE_NAME), COLUMN_NAME, 'IsIdentity')) AS [IDENT], "+ 919 | @"CHARACTER_MAXIMUM_LENGTH AS CSIZE "+ 920 | "FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = '" + tableName + "' ORDER BY " + 921 | "ORDINAL_POSITION ASC", conn); 922 | using (SqlDataReader reader = cmd.ExecuteReader()) 923 | { 924 | while (reader.Read()) 925 | { 926 | object tmp = reader["COLUMN_NAME"]; 927 | if (tmp is DBNull) 928 | continue; 929 | string colName = (string)reader["COLUMN_NAME"]; 930 | 931 | tmp = reader["COLUMN_DEFAULT"]; 932 | string colDefault; 933 | if (tmp is DBNull) 934 | colDefault = string.Empty; 935 | else 936 | colDefault = (string)tmp; 937 | 938 | tmp = reader["IS_NULLABLE"]; 939 | bool isNullable = ((string)tmp == "YES"); 940 | string dataType = (string)reader["DATA_TYPE"]; 941 | bool isIdentity = false; 942 | if (reader["IDENT"] != DBNull.Value) 943 | isIdentity = ((int)reader["IDENT"]) == 1 ? true : false; 944 | int length = reader["CSIZE"] != DBNull.Value ? Convert.ToInt32(reader["CSIZE"]) : 0; 945 | 946 | ValidateDataType(dataType); 947 | 948 | // Note that not all data type names need to be converted because 949 | // SQLite establishes type affinity by searching certain strings 950 | // in the type name. For example - everything containing the string 951 | // 'int' in its type name will be assigned an INTEGER affinity 952 | if (dataType == "timestamp") 953 | dataType = "blob"; 954 | else if (dataType == "date") 955 | dataType = "date"; 956 | else if (dataType == "datetime" || dataType == "smalldatetime" || dataType == "datetime2") 957 | dataType = "datetime"; 958 | else if (dataType == "time") 959 | dataType = "datetime"; 960 | else if (dataType == "decimal") 961 | dataType = "numeric"; 962 | else if (dataType == "money" || dataType == "smallmoney") 963 | dataType = "numeric"; 964 | else if (dataType == "binary" || dataType == "varbinary" || 965 | dataType == "image") 966 | dataType = "blob"; 967 | else if (dataType == "tinyint") 968 | dataType = "smallint"; 969 | else if (dataType == "bigint") 970 | dataType = "integer"; 971 | else if (dataType == "sql_variant") 972 | dataType = "blob"; 973 | else if (dataType == "xml") 974 | dataType = "varchar"; 975 | else if (dataType == "uniqueidentifier") 976 | dataType = "guid"; 977 | else if (dataType == "ntext") 978 | dataType = "text"; 979 | else if (dataType == "nchar") 980 | dataType = "char"; 981 | 982 | if (dataType == "bit" || dataType == "int") 983 | { 984 | if (colDefault == "('False')") 985 | colDefault = "(0)"; 986 | else if (colDefault == "('True')") 987 | colDefault = "(1)"; 988 | } 989 | 990 | colDefault = FixDefaultValueString(colDefault); 991 | 992 | ColumnSchema col = new ColumnSchema(); 993 | col.ColumnName = colName; 994 | col.ColumnType = dataType; 995 | col.Length = length; 996 | col.IsNullable = isNullable; 997 | col.IsIdentity = isIdentity; 998 | col.DefaultValue = AdjustDefaultValue(colDefault); 999 | res.Columns.Add(col); 1000 | } // while 1001 | } // using 1002 | 1003 | // Find PRIMARY KEY information 1004 | SqlCommand cmd2 = new SqlCommand(@"EXEC sp_pkeys '" + tableName + "'", conn); 1005 | using (SqlDataReader reader = cmd2.ExecuteReader()) 1006 | { 1007 | res.PrimaryKey = new List(); 1008 | while (reader.Read()) 1009 | { 1010 | string colName = (string)reader["COLUMN_NAME"]; 1011 | res.PrimaryKey.Add(colName); 1012 | } // while 1013 | } // using 1014 | 1015 | // Find COLLATE information for all columns in the table 1016 | SqlCommand cmd4 = new SqlCommand( 1017 | @"EXEC sp_tablecollations '" + tschma + "." + tableName + "'", conn); 1018 | using (SqlDataReader reader = cmd4.ExecuteReader()) 1019 | { 1020 | while (reader.Read()) 1021 | { 1022 | bool? isCaseSensitive = null; 1023 | string colName = (string)reader["name"]; 1024 | if (reader["tds_collation"] != DBNull.Value) 1025 | { 1026 | byte[] mask = (byte[])reader["tds_collation"]; 1027 | if ((mask[2] & 0x10) != 0) 1028 | isCaseSensitive = false; 1029 | else 1030 | isCaseSensitive = true; 1031 | } // if 1032 | 1033 | if (isCaseSensitive.HasValue) 1034 | { 1035 | // Update the corresponding column schema. 1036 | foreach (ColumnSchema csc in res.Columns) 1037 | { 1038 | if (csc.ColumnName == colName) 1039 | { 1040 | csc.IsCaseSensitivite = isCaseSensitive; 1041 | break; 1042 | } 1043 | } // foreach 1044 | } // if 1045 | } // while 1046 | } // using 1047 | 1048 | try 1049 | { 1050 | // Find index information 1051 | SqlCommand cmd3 = new SqlCommand( 1052 | @"exec sp_helpindex '" + tschma + "." + tableName + "'", conn); 1053 | using (SqlDataReader reader = cmd3.ExecuteReader()) 1054 | { 1055 | res.Indexes = new List(); 1056 | while (reader.Read()) 1057 | { 1058 | string indexName = (string)reader["index_name"]; 1059 | string desc = (string)reader["index_description"]; 1060 | string keys = (string)reader["index_keys"]; 1061 | 1062 | // Don't add the index if it is actually a primary key index 1063 | if (desc.Contains("primary key")) 1064 | continue; 1065 | 1066 | IndexSchema index = BuildIndexSchema(indexName, desc, keys); 1067 | res.Indexes.Add(index); 1068 | } // while 1069 | } // using 1070 | } 1071 | catch (Exception ex) 1072 | { 1073 | _log.Warn("failed to read index information for table [" + tableName + "]"); 1074 | } // catch 1075 | 1076 | return res; 1077 | } 1078 | 1079 | ///

1080 | /// Small validation method to make sure we don't miss anything without getting 1081 | /// an exception. 1082 | ///

1083 | /// The datatype to validate. 1084 | private static void ValidateDataType(string dataType) 1085 | { 1086 | if (dataType == "int" || dataType == "smallint" || 1087 | dataType == "bit" || dataType == "float" || 1088 | dataType == "real" || dataType == "nvarchar" || 1089 | dataType == "varchar" || dataType == "timestamp" || 1090 | dataType == "varbinary" || dataType == "image" || 1091 | dataType == "text" || dataType == "ntext" || 1092 | dataType == "bigint" || 1093 | dataType == "char" || dataType == "numeric" || 1094 | dataType == "binary" || dataType == "smalldatetime" || 1095 | dataType == "smallmoney" || dataType == "money" || 1096 | dataType == "tinyint" || dataType == "uniqueidentifier" || 1097 | dataType == "xml" || dataType == "sql_variant" || 1098 | dataType == "decimal" || dataType == "nchar" || 1099 | dataType == "date" || 1100 | dataType == "time" || 1101 | dataType == "datetime" || dataType == "datetime2") 1102 | return; 1103 | throw new ApplicationException("Validation failed for data type [" + dataType + "]"); 1104 | } 1105 | 1106 | ///

1107 | /// Does some necessary adjustments to a value string that appears in a column DEFAULT 1108 | /// clause. 1109 | ///

1110 | /// The original default value string (as read from SQL Server). 1111 | /// Adjusted DEFAULT value string (for SQLite) 1112 | private static string FixDefaultValueString(string colDefault) 1113 | { 1114 | bool replaced = false; 1115 | string res = colDefault.Trim(); 1116 | 1117 | // Find first/last indexes in which to search 1118 | int first = -1; 1119 | int last = -1; 1120 | for (int i = 0; i < res.Length; i++) 1121 | { 1122 | if (res[i] == '\'' && first == -1) 1123 | first = i; 1124 | if (res[i] == '\'' && first != -1 && i > last) 1125 | last = i; 1126 | } // for 1127 | 1128 | if (first != -1 && last > first) 1129 | return res.Substring(first, last - first + 1); 1130 | 1131 | StringBuilder sb = new StringBuilder(); 1132 | for (int i = 0; i < res.Length; i++) 1133 | { 1134 | if (res[i] != '(' && res[i] != ')') 1135 | { 1136 | sb.Append(res[i]); 1137 | replaced = true; 1138 | } 1139 | } 1140 | if (replaced) 1141 | return "(" + sb.ToString() + ")"; 1142 | else 1143 | return sb.ToString(); 1144 | } 1145 | 1146 | 1147 | 1148 | ///

1149 | /// Add foreign key schema object from the specified components (Read from SQL Server). 1150 | ///

1151 | /// The SQL Server connection to use 1152 | /// The table schema to whom foreign key schema should be added to 1153 | private static void CreateForeignKeySchema(SqlConnection conn, TableSchema ts) 1154 | { 1155 | ts.ForeignKeys = new List(); 1156 | 1157 | SqlCommand cmd = new SqlCommand( 1158 | @"SELECT " + 1159 | @" ColumnName = CU.COLUMN_NAME, " + 1160 | @" ForeignTableName = PK.TABLE_NAME, " + 1161 | @" ForeignColumnName = PT.COLUMN_NAME, " + 1162 | @" DeleteRule = C.DELETE_RULE, " + 1163 | @" IsNullable = COL.IS_NULLABLE " + 1164 | @"FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS C " + 1165 | @"INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS FK ON C.CONSTRAINT_NAME = FK.CONSTRAINT_NAME " + 1166 | @"INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS PK ON C.UNIQUE_CONSTRAINT_NAME = PK.CONSTRAINT_NAME " + 1167 | @"INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CU ON C.CONSTRAINT_NAME = CU.CONSTRAINT_NAME " + 1168 | @"INNER JOIN " + 1169 | @" ( " + 1170 | @" SELECT i1.TABLE_NAME, i2.COLUMN_NAME " + 1171 | @" FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS i1 " + 1172 | @" INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE i2 ON i1.CONSTRAINT_NAME = i2.CONSTRAINT_NAME " + 1173 | @" WHERE i1.CONSTRAINT_TYPE = 'PRIMARY KEY' " + 1174 | @" ) " + 1175 | @"PT ON PT.TABLE_NAME = PK.TABLE_NAME " + 1176 | @"INNER JOIN INFORMATION_SCHEMA.COLUMNS AS COL ON CU.COLUMN_NAME = COL.COLUMN_NAME AND FK.TABLE_NAME = COL.TABLE_NAME " + 1177 | @"WHERE FK.Table_NAME='" + ts.TableName + "'", conn); 1178 | 1179 | using (SqlDataReader reader = cmd.ExecuteReader()) 1180 | { 1181 | while (reader.Read()) 1182 | { 1183 | ForeignKeySchema fkc = new ForeignKeySchema(); 1184 | fkc.ColumnName = (string)reader["ColumnName"]; 1185 | fkc.ForeignTableName = (string)reader["ForeignTableName"]; 1186 | fkc.ForeignColumnName = (string)reader["ForeignColumnName"]; 1187 | fkc.CascadeOnDelete = (string)reader["DeleteRule"] == "CASCADE"; 1188 | fkc.IsNullable = (string)reader["IsNullable"] == "YES"; 1189 | fkc.TableName = ts.TableName; 1190 | ts.ForeignKeys.Add(fkc); 1191 | } 1192 | } 1193 | } 1194 | 1195 | ///

1196 | /// Builds an index schema object from the specified components (Read from SQL Server). 1197 | ///

1198 | /// The name of the index 1199 | /// The description of the index 1200 | /// Key columns that are part of the index. 1201 | /// An index schema object that represents our knowledge of the index 1202 | private static IndexSchema BuildIndexSchema(string indexName, string desc, string keys) 1203 | { 1204 | IndexSchema res = new IndexSchema(); 1205 | res.IndexName = indexName; 1206 | 1207 | // Determine if this is a unique index or not. 1208 | string[] descParts = desc.Split(','); 1209 | foreach (string p in descParts) 1210 | { 1211 | if (p.Trim().Contains("unique")) 1212 | { 1213 | res.IsUnique = true; 1214 | break; 1215 | } 1216 | } // foreach 1217 | 1218 | // Get all key names and check if they are ASCENDING or DESCENDING 1219 | res.Columns = new List(); 1220 | string[] keysParts = keys.Split(','); 1221 | foreach (string p in keysParts) 1222 | { 1223 | Match m = _keyRx.Match(p); 1224 | if (!m.Success) 1225 | { 1226 | throw new ApplicationException("Illegal key name [" + p + "] in index [" + 1227 | indexName + "]"); 1228 | } 1229 | 1230 | string key = m.Groups[1].Value; 1231 | IndexColumn ic = new IndexColumn(); 1232 | ic.ColumnName = key; 1233 | if (m.Groups[2].Success) 1234 | ic.IsAscending = false; 1235 | else 1236 | ic.IsAscending = true; 1237 | 1238 | res.Columns.Add(ic); 1239 | } // foreach 1240 | 1241 | return res; 1242 | } 1243 | 1244 | ///

1245 | /// More adjustments for the DEFAULT value clause. 1246 | ///

1247 | /// The value to adjust 1248 | /// Adjusted DEFAULT value string 1249 | private static string AdjustDefaultValue(string val) 1250 | { 1251 | if (val == null || val == string.Empty) 1252 | return val; 1253 | 1254 | Match m = _defaultValueRx.Match(val); 1255 | if (m.Success) 1256 | return m.Groups[1].Value; 1257 | return val; 1258 | } 1259 | 1260 | ///

1261 | /// Creates SQLite connection string from the specified DB file path. 1262 | ///

1263 | /// The path to the SQLite database file. 1264 | /// SQLite connection string 1265 | private static string CreateSQLiteConnectionString(string sqlitePath, string password) 1266 | { 1267 | SQLiteConnectionStringBuilder builder = new SQLiteConnectionStringBuilder(); 1268 | builder.DataSource = sqlitePath; 1269 | if (password != null) 1270 | builder.Password = password; 1271 | builder.PageSize = 4096; 1272 | builder.UseUTF16Encoding = true; 1273 | string connstring = builder.ConnectionString; 1274 | 1275 | return connstring; 1276 | } 1277 | #endregion 1278 | 1279 | #region Trigger related 1280 | private static void AddTriggersForForeignKeys(string sqlitePath, IEnumerable schema, 1281 | string password, SqlConversionHandler handler) 1282 | { 1283 | // Connect to the newly created database 1284 | string sqliteConnString = CreateSQLiteConnectionString(sqlitePath, password); 1285 | using (SQLiteConnection conn = new SQLiteConnection(sqliteConnString)) 1286 | { 1287 | conn.Open(); 1288 | // foreach 1289 | foreach (TableSchema dt in schema) 1290 | { 1291 | try 1292 | { 1293 | AddTableTriggers(conn, dt); 1294 | } 1295 | catch (Exception ex) 1296 | { 1297 | _log.Error("AddTableTriggers failed", ex); 1298 | throw; 1299 | } 1300 | } 1301 | 1302 | } // using 1303 | 1304 | _log.Debug("finished adding triggers to schema"); 1305 | } 1306 | 1307 | private static void AddTableTriggers(SQLiteConnection conn, TableSchema dt) 1308 | { 1309 | IList triggers = TriggerBuilder.GetForeignKeyTriggers(dt); 1310 | foreach (TriggerSchema trigger in triggers) 1311 | { 1312 | SQLiteCommand cmd = new SQLiteCommand(WriteTriggerSchema(trigger), conn); 1313 | cmd.ExecuteNonQuery(); 1314 | } 1315 | } 1316 | #endregion 1317 | 1318 | ///

1319 | /// Gets a create script for the triggerSchema in sqlite syntax 1320 | ///

1321 | /// Trigger to script 1322 | /// Executable script 1323 | public static string WriteTriggerSchema(TriggerSchema ts) 1324 | { 1325 | return @"CREATE TRIGGER [" + ts.Name + "] " + 1326 | ts.Type + " " + ts.Event + 1327 | " ON [" + ts.Table + "] " + 1328 | "BEGIN " + ts.Body + " END;"; 1329 | } 1330 | 1331 | #region Private Variables 1332 | private static bool _isActive = false; 1333 | private static bool _cancelled = false; 1334 | private static Regex _keyRx = new Regex(@"([a-zA-Z_0-9]+)(\(\-\))?"); 1335 | private static Regex _defaultValueRx = new Regex(@"\(N(\'.*\')\)"); 1336 | private static ILog _log = LogManager.GetLogger(typeof(SqlServerToSQLite)); 1337 | #endregion 1338 | } 1339 | 1340 | ///

1341 | /// This handler is called whenever a progress is made in the conversion process. 1342 | ///

1343 | /// TRUE indicates that the entire conversion process is finished. 1344 | /// TRUE indicates that the current step finished successfully. 1345 | /// Progress percent (0-100) 1346 | /// A message that accompanies the progress. 1347 | public delegate void SqlConversionHandler(bool done, bool success, int percent, string msg); 1348 | 1349 | ///

1350 | /// This handler allows the user to change which tables get converted from SQL Server 1351 | /// to SQLite. 1352 | ///

1353 | /// The original SQL Server DB schema 1354 | /// The same schema minus any table we don't want to convert. 1355 | public delegate List SqlTableSelectionHandler(List schema); 1356 | 1357 | ///

1358 | /// This handler is called in order to handle the case when copying the SQL Server view SQL 1359 | /// statement is not enough and the user needs to either update the view definition himself 1360 | /// or discard the view definition from the generated SQLite database. 1361 | ///

1362 | /// The problematic view definition 1363 | /// The updated view definition, or NULL in case the view should be discarded 1364 | public delegate string FailedViewDefinitionHandler(ViewSchema vs); 1365 | } 1366 | -------------------------------------------------------------------------------- /DbAccess/TableSchema.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | public class TableSchema 8 | { 9 | public string TableName; 10 | 11 | public string TableSchemaName; 12 | 13 | public List Columns; 14 | 15 | public List PrimaryKey; 16 | 17 | public List ForeignKeys; 18 | 19 | public List Indexes; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /DbAccess/TriggerBuilder.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | 8 | public static class TriggerBuilder 9 | { 10 | public static IList GetForeignKeyTriggers(TableSchema dt) 11 | { 12 | IList result = new List(); 13 | 14 | foreach (ForeignKeySchema fks in dt.ForeignKeys) 15 | { 16 | StringBuilder sb = new StringBuilder(); 17 | result.Add(GenerateInsertTrigger(fks)); 18 | result.Add(GenerateUpdateTrigger(fks)); 19 | result.Add(GenerateDeleteTrigger(fks)); 20 | } 21 | return result; 22 | } 23 | 24 | private static string MakeTriggerName(ForeignKeySchema fks, string prefix) 25 | { 26 | return prefix + "_"+fks.TableName + "_" + fks.ColumnName + "_" + fks.ForeignTableName + "_" + fks.ForeignColumnName; 27 | } 28 | 29 | public static TriggerSchema GenerateInsertTrigger(ForeignKeySchema fks) 30 | { 31 | TriggerSchema trigger = new TriggerSchema(); 32 | trigger.Name = MakeTriggerName(fks, "fki"); 33 | trigger.Type = TriggerType.Before; 34 | trigger.Event = TriggerEvent.Insert; 35 | trigger.Table = fks.TableName; 36 | 37 | string nullString = ""; 38 | if (fks.IsNullable) 39 | { 40 | nullString = " NEW." + fks.ColumnName + " IS NOT NULL AND"; 41 | } 42 | 43 | trigger.Body = "SELECT RAISE(ROLLBACK, 'insert on table " + fks.TableName + 44 | " violates foreign key constraint " + trigger.Name + "')" + 45 | " WHERE" + nullString + " (SELECT " + fks.ForeignColumnName + 46 | " FROM " + fks.ForeignTableName + " WHERE " + fks.ForeignColumnName + " = NEW." + 47 | fks.ColumnName + 48 | ") IS NULL; " ; 49 | return trigger; 50 | } 51 | 52 | public static TriggerSchema GenerateUpdateTrigger(ForeignKeySchema fks) 53 | { 54 | TriggerSchema trigger = new TriggerSchema(); 55 | trigger.Name = MakeTriggerName(fks, "fku"); 56 | trigger.Type = TriggerType.Before; 57 | trigger.Event = TriggerEvent.Update; 58 | trigger.Table = fks.TableName; 59 | 60 | string triggerName = trigger.Name; 61 | string nullString = ""; 62 | if (fks.IsNullable) 63 | { 64 | nullString = " NEW." + fks.ColumnName + " IS NOT NULL AND"; 65 | } 66 | 67 | trigger.Body = "SELECT RAISE(ROLLBACK, 'update on table " + fks.TableName + 68 | " violates foreign key constraint " + triggerName + "')" + 69 | " WHERE" + nullString + " (SELECT " + fks.ForeignColumnName + 70 | " FROM " + fks.ForeignTableName + " WHERE " + fks.ForeignColumnName + " = NEW." + 71 | fks.ColumnName + 72 | ") IS NULL; "; 73 | 74 | return trigger; 75 | } 76 | 77 | public static TriggerSchema GenerateDeleteTrigger(ForeignKeySchema fks) 78 | { 79 | TriggerSchema trigger = new TriggerSchema(); 80 | trigger.Name = MakeTriggerName(fks, "fkd"); 81 | trigger.Type = TriggerType.Before; 82 | trigger.Event = TriggerEvent.Delete; 83 | trigger.Table = fks.ForeignTableName; 84 | 85 | string triggerName = trigger.Name; 86 | 87 | if (!fks.CascadeOnDelete) 88 | { 89 | trigger.Body = "SELECT RAISE(ROLLBACK, 'delete on table " + fks.ForeignTableName + 90 | " violates foreign key constraint " + triggerName + "')" + 91 | " WHERE (SELECT " + fks.ColumnName + 92 | " FROM " + fks.TableName + " WHERE " + fks.ColumnName + " = OLD." + 93 | fks.ForeignColumnName + 94 | ") IS NOT NULL; "; 95 | } 96 | else 97 | { 98 | trigger.Body = "DELETE FROM [" + fks.TableName + "] WHERE " + fks.ColumnName + " = OLD." + 99 | fks.ForeignColumnName + "; "; 100 | 101 | } 102 | return trigger; 103 | } 104 | } 105 | } 106 | -------------------------------------------------------------------------------- /DbAccess/TriggerSchema.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | public enum TriggerEvent 8 | { 9 | Delete, 10 | Update, 11 | Insert 12 | } 13 | 14 | public enum TriggerType 15 | { 16 | After, 17 | Before 18 | } 19 | 20 | public class TriggerSchema 21 | { 22 | public string Name; 23 | public TriggerEvent Event; 24 | public TriggerType Type; 25 | public string Body; 26 | public string Table; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /DbAccess/ViewSchema.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Collections.Generic; 3 | using System.Text; 4 | 5 | namespace DbAccess 6 | { 7 | ///

8 | /// Describes a single view schema 9 | ///

10 | public class ViewSchema 11 | { 12 | ///

13 | /// Contains the view name 14 | ///

15 | public string ViewName; 16 | 17 | ///

18 | /// Contains the view SQL statement 19 | ///

20 | public string ViewSQL; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Convert SQL Server DB to SQLite DB # 2 | 3 | Liron Levi made a great converter over on CodeProject at [http://www.codeproject.com/KB/database/convsqlservertosqlite.aspx](http://www.codeproject.com/KB/database/convsqlservertosqlite.aspx) 4 | 5 | This project was placed in the public domain, so I've forked it on GitHub and made the following changes to the 1.16 version: 6 | 7 | 1. Converted to VS2010 solution/project format 8 | 2. Added support for SQL Server 2008 datetime2 format. 9 | 10 | There's probably other minor additions to be made to the project, but those two changes got me what I needed for now. 11 | 12 | Thanks Liron! 13 | -------------------------------------------------------------------------------- /SolutionInfo.cs: -------------------------------------------------------------------------------- 1 | using System.Reflection; 2 | using System.Runtime.CompilerServices; 3 | using System.Runtime.InteropServices; 4 | 5 | // General Information about an assembly is controlled through the following 6 | // set of attributes. Change these attribute values to modify the information 7 | // associated with an assembly. 8 | [assembly: AssemblyTitle("SQL Server To SQLite Converter")] 9 | [assembly: AssemblyDescription("Convert SQL Server databases to SQLite databases")] 10 | [assembly: AssemblyConfiguration("")] 11 | [assembly: AssemblyCompany("")] 12 | [assembly: AssemblyProduct("SQLite Converter")] 13 | [assembly: AssemblyTrademark("")] 14 | [assembly: AssemblyCulture("")] 15 | 16 | // Setting ComVisible to false makes the types in this assembly not visible 17 | // to COM components. If you need to access a type in this assembly from 18 | // COM, set the ComVisible attribute to true on that type. 19 | [assembly: ComVisible(false)] 20 | 21 | // The following GUID is for the ID of the typelib if this project is exposed to COM 22 | [assembly: Guid("5c16baa6-f948-40b6-a215-d454fd8c37d8")] 23 | 24 | // Version information for an assembly consists of the following four values: 25 | // 26 | // Major Version 27 | // Minor Version 28 | // Build Number 29 | // Revision 30 | // 31 | [assembly: AssemblyVersion("1.16.0.*")] 32 | //[assembly: AssemblyFileVersion("1.16.0.*")] 33 | -------------------------------------------------------------------------------- /SqlConverter.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 11.00 3 | # Visual Studio 2010 4 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "SolutionItems", "SolutionItems", "{BF532AE3-9E18-4534-BD02-F0DA395FB642}" 5 | ProjectSection(SolutionItems) = preProject 6 | SolutionInfo.cs = SolutionInfo.cs 7 | EndProjectSection 8 | EndProject 9 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Converter", "Converter\Converter.csproj", "{1D389047-977D-4278-8357-AC0AC751B95E}" 10 | EndProject 11 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DbAccess", "DbAccess\DbAccess.csproj", "{23AAF1EF-2EB6-43AD-8103-A687F04A7288}" 12 | EndProject 13 | Global 14 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 15 | Debug|Any CPU = Debug|Any CPU 16 | Release|Any CPU = Release|Any CPU 17 | EndGlobalSection 18 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 19 | {1D389047-977D-4278-8357-AC0AC751B95E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU 20 | {1D389047-977D-4278-8357-AC0AC751B95E}.Debug|Any CPU.Build.0 = Debug|Any CPU 21 | {1D389047-977D-4278-8357-AC0AC751B95E}.Release|Any CPU.ActiveCfg = Release|Any CPU 22 | {1D389047-977D-4278-8357-AC0AC751B95E}.Release|Any CPU.Build.0 = Release|Any CPU 23 | {23AAF1EF-2EB6-43AD-8103-A687F04A7288}.Debug|Any CPU.ActiveCfg = Debug|Any CPU 24 | {23AAF1EF-2EB6-43AD-8103-A687F04A7288}.Debug|Any CPU.Build.0 = Debug|Any CPU 25 | {23AAF1EF-2EB6-43AD-8103-A687F04A7288}.Release|Any CPU.ActiveCfg = Release|Any CPU 26 | {23AAF1EF-2EB6-43AD-8103-A687F04A7288}.Release|Any CPU.Build.0 = Release|Any CPU 27 | EndGlobalSection 28 | GlobalSection(SolutionProperties) = preSolution 29 | HideSolutionNode = FALSE 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /System.Data.SQLite.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/elerch/Convert-SQL-Server-to-SQLite/95436df861744d69630e642f42635f5b1669d108/System.Data.SQLite.dll -------------------------------------------------------------------------------- /log4net.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/elerch/Convert-SQL-Server-to-SQLite/95436df861744d69630e642f42635f5b1669d108/log4net.dll --------------------------------------------------------------------------------