/// <summary> /// Get database path based on which storage needed /// </summary> /// <param name="databaseDescriptor">Database Descriptor Object</param> /// <returns></returns> public String GetDatabasePath(DatabaseDescriptor databaseDescriptor) { DatabaseUtils databaseUtils = new DatabaseUtils(); String databasePath = null; bool isExternalStorageEnable = databaseDescriptor.IsExternalStorageEnable(); if (isExternalStorageEnable) { if (databaseUtils.IsSDCardPresent()) { databasePath = databaseUtils.SdcardMemoryDatabasePath(databaseDescriptor); } else { databasePath = databaseUtils.InternalMemoryDatabasePath(databaseDescriptor); } } else { databasePath = databaseUtils.InternalMemoryDatabasePath(databaseDescriptor); } return(databasePath); }
public void ExecuteBindQuery(DatabaseDescriptor databaseDescriptor, EntityDescriptor entityDescriptor, String query, IEnumerator <Object> columnValues) { Log.Log.Debug(typeof(DatabaseImpl).FullName, "ExecuteBindQuery", "QUERY: " + query); ICollection <Object> values = new List <Object>(); while (columnValues.MoveNext()) { values.Add(columnValues.Current); } try { sqliteDatabase.Execute(query, values.ToArray()); } catch (SQLiteException sqliteException) { if (sqliteDatabase.IsInTransaction) { sqliteDatabase.Rollback(); } Log.Log.Error(typeof(DatabaseImpl).FullName, "ExecuteBindQuery(" + query + ")", "SQLiteException caught while executing query, QUERY: " + query + ", " + sqliteException.Message); throw new DatabaseException(typeof(DatabaseImpl).FullName, "ExecuteBindQuery(" + query + ")", "SQLiteException caught while executing query, QUERY: " + query + ", " + sqliteException.Message); } }
private DatabaseRegistry LoadConfig() { //var appEnv = CallContextServiceLocator.Locator.ServiceProvider.GetService(typeof(IApplicationEnvironment)) as IApplicationEnvironment; //var basePath = appEnv.ApplicationBasePath; var path = Setting.Instance.Get("DbSettingFilePath"); var builder = new ConfigurationBuilder() .AddJsonFile(path); var configuration = builder.Build(); var databaseRegistry = new DatabaseRegistry(); var descriptors = new List <DatabaseDescriptor>(); foreach (var item in configuration.GetSection("databaseRegistry:databaseDescriptors").GetChildren()) { var descriptor = new DatabaseDescriptor(); descriptor.Name = item.GetSection("databaseDescriptor").Value; descriptor.Address = item.GetSection("address").Value; descriptor.DatabaseName = item.GetSection("databaseName").Value; descriptor.DatabaseType = EnumUtil.ParseEnum <DatabaseType>(item.GetSection("databaseType").Value); descriptor.UserName = item.GetSection("userName").Value; descriptor.Password = item.GetSection("password").Value; descriptors.Add(descriptor); } databaseRegistry.DatabaseDescriptors = descriptors; return(databaseRegistry); }
/// <summary> /// It is used to check whether database exists or not. /// </summary> protected static void DoesDatabaseExists() { ApplicationDescriptor applicationDescriptor = coreResourceManager.GetApplicationDescriptor(); IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors(); bool databaseExists = true; while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; String databasePath = new DatabaseUtils().GetDatabasePath(databaseDescriptor); String databaseName = databaseDescriptor.GetDatabaseName(); if (!databaseName.EndsWith(".db")) { databaseName = databaseName + ".db"; } bool fileExists = FileUtils.DoesFileExists(databasePath, databaseName, FileUtils.LOCAL_FOLDER); if (!fileExists) { databaseExists = false; } } if (!databaseExists) { firstTimeProcessed = true; } else { firstTimeProcessed = false; } }
/// <summary> /// It process all DatabaseDescriptor.xml files defined by Application and stores in Resource Manager. /// </summary> protected static void ProcessDatabaseDescriptors() { Core.Siminov.ProcessDatabaseDescriptors(); DatabaseDescriptorReader databaseDescriptorReader = new DatabaseDescriptorReader(Constants.DATABASE_DESSCRIPTOR_PATH); DatabaseDescriptor databaseDescriptor = databaseDescriptorReader.GetDatabaseDescriptor(); Connect.Model.ApplicationDescriptor applicationDescriptor = connectResourceManager.GetApplicationDescriptor(); applicationDescriptor.AddDatabaseDescriptor(Constants.DATABASE_DESSCRIPTOR_PATH, databaseDescriptor); }
/// <summary> /// Parse the entity descriptor descriptor defined /// </summary> /// <exception cref="Siminov.Core.Exception.SiminovException">Any exception during parsing the descriptor file</exception> public void Process() { ApplicationDescriptor applicationDescriptor = resourceManager.GetApplicationDescriptor(); if (applicationDescriptor == null) { Log.Log.Error(typeof(QuickEntityDescriptorReader).FullName, "Process", "Invalid Application Descriptor Found"); throw new DeploymentException(typeof(QuickEntityDescriptorReader).FullName, "Process", "Invalid Application Descriptor Found."); } if (!applicationDescriptor.IsDatabaseNeeded()) { doesMatch = false; return; } IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors(); while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; IEnumerator <String> entityDescriptors = databaseDescriptor.GetEntityDescriptorPaths(); while (entityDescriptors.MoveNext()) { String entityDescriptorPath = entityDescriptors.Current; Stream entityDescriptorStream = null; try { ParseMessage(entityDescriptorStream); } catch (SiminovException exception) { Log.Log.Error(typeof(QuickEntityDescriptorReader).FullName, "Process", "Exception caught while parsing ENTITY-DESCRIPTOR: " + entityDescriptorPath + ", " + exception.GetMessage()); throw new SiminovException(typeof(QuickEntityDescriptorReader).FullName, "Process", "Exception caught while parsing ENTITY-DESCRIPTOR: " + entityDescriptorPath + ", " + exception.GetMessage()); } if (doesMatch) { EntityDescriptorReader entityDescriptorParser = new EntityDescriptorReader(entityDescriptorPath); this.entityDescriptor = entityDescriptorParser.GetEntityDescriptor(); databaseDescriptor.AddEntityDescriptor(entityDescriptorPath, entityDescriptor); return; } } } }
/// <summary> /// Get sdcard database path /// </summary> /// <param name="databaseDescriptor">Database Descriptor Object</param> /// <returns></returns> public String SdcardMemoryDatabasePath(DatabaseDescriptor databaseDescriptor) { /*File externalStorage = Environment.GetExternalStorageDirectory(); * String externalStoragePath = externalStorage.GetAbsolutePath(); * * ResourceManager resourceManager = ResourceManager.GetInstance(); * ApplicationDescriptor applicationDescriptor = resourceManager.GetApplicationDescriptor(); * * String databaseDirName = databaseDescriptor.GetDatabaseName(); * * String databaseDirPath = externalStoragePath + File.separator + applicationDescriptor.getName() + File.separator + Constants.DATABASE_PATH_DATABASE + File.separator + databaseDirName + File.separator; * return databaseDirPath;*/ return(""); }
public override void StartElement(XmlReader reader, IDictionary <String, String> attributes) { String localName = reader.Name; tempValue = new StringBuilder(); if (localName.Equals(Constants.DATABASE_DESCRIPTOR, StringComparison.OrdinalIgnoreCase)) { databaseDescriptor = new DatabaseDescriptor(); } else if (localName.Equals(Constants.DATABASE_DESCRIPTOR_PROPERTY, StringComparison.OrdinalIgnoreCase)) { InitializeProperty(attributes); } }
/// <summary> /// Get internal memory database path /// </summary> /// <param name="databaseDescriptor">Database Descriptor Object</param> /// <returns></returns> public String InternalMemoryDatabasePath(DatabaseDescriptor databaseDescriptor) { #if XAMARIN var rootFolder = FileSystem.Current.LocalStorage; return(rootFolder.Path); #elif WINDOWS ResourceManager resourceManager = ResourceManager.GetInstance(); ApplicationDescriptor applicationDescriptor = resourceManager.GetApplicationDescriptor(); String databaseDirName = databaseDescriptor.GetDatabaseName(); String databaseDirPath = applicationDescriptor.GetName() + FileUtils.Separator + Constants.DATABASE_PATH_DATABASE + FileUtils.Separator + databaseDirName + FileUtils.Separator; return(databaseDirPath); #endif }
/// <summary> /// Get IDatabase Instance /// </summary> /// <param name="databaseDescriptor">DatabaseDescriptor Object</param> /// <returns>IDatabase Object</returns> /// <exception cref="Siminov.Core.Exception.DatabaseException">If not able to create IDatabase instance</exception> public DatabaseBundle GetDatabaseBundle(DatabaseDescriptor databaseDescriptor) { if (databaseBundles.ContainsKey(databaseDescriptor.GetDatabaseName())) { return(databaseBundles[databaseDescriptor.GetDatabaseName()]); } String type = databaseDescriptor.GetType(); String packageName = DATABASE_PACKAGE_NAME + "." + type; DatabaseBundle databaseBundle = GetDatabaseBundle(packageName); databaseBundles.Add(databaseDescriptor.GetDatabaseName(), databaseBundle); return(databaseBundle); }
public void OpenOrCreate(DatabaseDescriptor databaseDescriptor) { String databasePath = new DatabaseUtils().GetDatabasePath(databaseDescriptor); if (!FileUtils.DoesFolderExists(databasePath, FileUtils.LOCAL_FOLDER)) { try { FileUtils.CreateFolder(databasePath, FileUtils.LOCAL_FOLDER); } catch (System.Exception exception) { Log.Log.Error(typeof(DatabaseImpl).FullName, "OpenOrCreate", "Exception caught while creating database directories, DATABASE-PATH: " + databasePath + ", DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + exception.Message); throw new DeploymentException(typeof(DatabaseImpl).FullName, "OpenOrCreate", "Exception caught while creating database directories, DATABASE-PATH: " + databasePath + ", DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + exception.Message); } } String databaseName = databaseDescriptor.GetDatabaseName(); if (databaseName == null || databaseName.Length <= 0) { Log.Log.Error(typeof(DatabaseImpl).FullName, "OpenOrCreate", "DATABASE-NAME IS MANDATORY FIELD - DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); throw new DatabaseException(typeof(DatabaseImpl).FullName, "OpenOrCreate", "DATABASE-NAME IS MANDATORY FIELD - DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); } if (!databaseName.EndsWith(".db")) { databaseName = databaseName + ".db"; } try { #if XAMARIN String databaseURI = Path.Combine(databasePath, databaseName); sqliteDatabase = new SQLiteConnection(databaseURI); #elif WINDOWS sqliteDatabase = new SQLiteConnection(databasePath + databaseName); #endif } catch (SQLiteException sqliteException) { Log.Log.Error(typeof(DatabaseImpl).FullName, "OpenOrCreate", "SQLiteException caught while opening database, " + sqliteException.Message); throw new DatabaseException(typeof(DatabaseImpl).FullName, "OpenOrCreate", "SQLiteException caught while opening database, " + sqliteException.Message); } }
/// <summary> /// Get all entity descriptors /// </summary> /// <returns>Entity Descriptors</returns> public IEnumerator <EntityDescriptor> GetEntityDescriptors() { ICollection <EntityDescriptor> entityDescriptors = new LinkedList <EntityDescriptor>(); IEnumerator <DatabaseDescriptor> databaseDescriptors = this.applicationDescriptor.GetDatabaseDescriptors(); while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; IEnumerator <EntityDescriptor> descriptors = databaseDescriptor.GetEntityDescriptors(); while (descriptors.MoveNext()) { EntityDescriptor entityDescriptor = descriptors.Current; entityDescriptors.Add(entityDescriptor); } } return(entityDescriptors.GetEnumerator()); }
public void ExecuteQuery(DatabaseDescriptor databaseDescriptor, EntityDescriptor entityDescriptor, String query) { Log.Log.Debug(typeof(DatabaseImpl).FullName, "ExecuteQuery(" + query + ")", "QUERY: " + query); try { sqliteDatabase.Execute(query); } catch (SQLiteException sqliteException) { if (sqliteDatabase.IsInTransaction) { sqliteDatabase.Rollback(); } Log.Log.Error(typeof(DatabaseImpl).FullName, "ExecuteQuery(" + query + ")", "SQLiteException caught while executing query, QUERY: " + query + ", " + sqliteException.Message); throw new DatabaseException(typeof(DatabaseImpl).FullName, "ExecuteQuery(" + query + ")", "SQLiteException caught while executing query, QUERY: " + query + ", " + sqliteException.Message); } }
/// <summary> /// It process all DatabaseDescriptor.xml files defined by Application and stores in Resource Manager. /// </summary> protected static void ProcessDatabaseDescriptors() { IEnumerator <String> databaseDescriptorPaths = coreResourceManager.GetApplicationDescriptor().GetDatabaseDescriptorPaths(); while (databaseDescriptorPaths.MoveNext()) { String databaseDescriptorPath = databaseDescriptorPaths.Current; DatabaseDescriptorReader databaseDescriptorParser = new DatabaseDescriptorReader(databaseDescriptorPath); DatabaseDescriptor databaseDescriptor = databaseDescriptorParser.GetDatabaseDescriptor(); if (databaseDescriptor == null) { Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabaseDescriptors", "Invalid Database Descriptor Path Found, DATABASE-DESCRIPTOR: " + databaseDescriptorPath); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabaseDescriptors", "Invalid Database Descriptor Path Found, DATABASE-DESCRIPTOR: " + databaseDescriptorPath); } coreResourceManager.GetApplicationDescriptor().AddDatabaseDescriptor(databaseDescriptorPath, databaseDescriptor); } }
/// <summary> /// It process all LibraryDescriptor.xml files defined by application, and stores in Resource Manager. /// </summary> protected static void ProcessLibraries() { ApplicationDescriptor applicationDescriptor = coreResourceManager.GetApplicationDescriptor(); IEnumerator <String> libraries = applicationDescriptor.GetLibraryDescriptorPaths(); while (libraries.MoveNext()) { String library = libraries.Current; /* * Parse LibraryDescriptor. */ LibraryDescriptorReader libraryDescriptorReader = new LibraryDescriptorReader(library); LibraryDescriptor libraryDescriptor = libraryDescriptorReader.GetLibraryDescriptor(); /* * Map Entity Descriptors */ IEnumerator <String> entityDescriptors = libraryDescriptor.GetEntityDescriptorPaths(); while (entityDescriptors.MoveNext()) { String libraryEntityDescriptorPath = entityDescriptors.Current; String databaseDescriptorName = libraryEntityDescriptorPath.Substring(0, libraryEntityDescriptorPath.IndexOf(Constants.LIBRARY_DESCRIPTOR_ENTITY_DESCRIPTOR_SEPRATOR)); String entityDescriptor = libraryEntityDescriptorPath.Substring(libraryEntityDescriptorPath.IndexOf(Constants.LIBRARY_DESCRIPTOR_ENTITY_DESCRIPTOR_SEPRATOR) + 1, ((libraryEntityDescriptorPath.Length - libraryEntityDescriptorPath.IndexOf(Constants.LIBRARY_DESCRIPTOR_ENTITY_DESCRIPTOR_SEPRATOR)) - 1)); IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors(); while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; if (databaseDescriptor.GetDatabaseName().Equals(databaseDescriptorName, StringComparison.OrdinalIgnoreCase)) { databaseDescriptor.AddEntityDescriptorPath(library.Replace(".", "/") + FileUtils.Separator + entityDescriptor); } } } } }
/// <summary> /// It process all EntityDescriptor.xml file defined in Application, and stores in Resource Manager. /// </summary> protected static void ProcessEntityDescriptors() { DoesDatabaseExists(); ApplicationDescriptor applicationDescriptor = coreResourceManager.GetApplicationDescriptor(); IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors(); while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; IEnumerator <String> entityDescriptorPaths = databaseDescriptor.GetEntityDescriptorPaths(); while (entityDescriptorPaths.MoveNext()) { String entityDescriptorPath = entityDescriptorPaths.Current; EntityDescriptorReader entityDescriptorParser = new EntityDescriptorReader(entityDescriptorPath); databaseDescriptor.AddEntityDescriptor(entityDescriptorPath, entityDescriptorParser.GetEntityDescriptor()); } } }
/// <summary> /// Get Entity Descriptor based on table name provided. /// </summary> /// <param name="tableName">Name of table</param> /// <returns>Entity Descriptor object in respect to table name.</returns> public EntityDescriptor GetEntityDescriptorBasedOnTableName(String tableName) { if (this.applicationDescriptor == null) { throw new DeploymentException(typeof(ResourceManager).FullName, "GetEntityDescriptorBasedOnTableName", "Siminov Not Active, INVALID APPLICATION-DESCRIPTOR FOUND"); } IEnumerator <DatabaseDescriptor> databaseDescriptors = this.applicationDescriptor.GetDatabaseDescriptors(); while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; bool containsEntityDescriptorInDatabaseDescriptor = databaseDescriptor.ContainsEntityDescriptorBasedOnTableName(tableName); if (containsEntityDescriptorInDatabaseDescriptor) { return(databaseDescriptor.GetEntityDescriptorBasedOnTableName(tableName)); } } return(null); }
/// <summary> /// It is used to stop all service started by SIMINOV. /// When application shutdown they should call this. It do following services: /// /// <list type="bullet"> /// <item> /// <description>Close all database's opened by SIMINOV.</description> /// </item> /// <item> /// <description>Deallocate all resources held by SIMINOV.</description> /// </item> /// </list> /// </summary> public static void Shutdown() { IsActive(); IEnumerator <DatabaseDescriptor> databaseDescriptors = coreResourceManager.GetDatabaseDescriptors(); bool failed = false; while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; DatabaseBundle databaseBundle = coreResourceManager.GetDatabaseBundle(databaseDescriptor.GetDatabaseName()); IDatabaseImpl database = databaseBundle.GetDatabase(); try { database.Close(databaseDescriptor); } catch (DatabaseException databaseException) { failed = true; Log.Log.Error(typeof(Siminov).FullName, "Shutdown", "DatabaseException caught while closing database, " + databaseException.GetMessage()); continue; } } if (failed) { throw new SiminovCriticalException(typeof(Siminov).FullName, "Shutdown", "DatabaseException caught while closing database."); } ISiminovEvents coreEventHandler = coreResourceManager.GetSiminovEventHandler(); if (coreResourceManager.GetSiminovEventHandler() != null) { coreEventHandler.OnSiminovStopped(); } }
/// <summary> /// Marks the current transaction as successful /// Finally it will End a transaction. /// <para> /// Example: Make Book Object /// <code> /// Book cBook = new Book(); /// cBook.SetTitle(Book.BOOK_TYPE_C); /// cBook.SetDescription("c_description"); /// cBook.SetAuthor("c_author"); /// cBook.SetLink("c_link"); /// /// DatabaseDescriptor databaseDescriptor = cBook.GetDatabaseDescriptor(); /// /// try { /// Database.BeginTransaction(databaseDescriptor); /// /// cBook.Save(); /// /// Database.CommitTransaction(databaseDescriptor); /// } catch(DatabaseException de) { /// //Log it. /// } finally { /// Database.EndTransaction(databaseDescriptor); /// } /// </code> /// </para> /// </summary> /// <param name="databaseDescriptor">Database Descriptor Object</param> /// <exception cref="Siminov.Core.Exception.DatabaseException">If not able to commit the transaction</exception> public static void CommitTransaction(DatabaseDescriptor databaseDescriptor) { DatabaseHelper.CommitTransaction(databaseDescriptor); }
/// <summary> /// End the current transaction /// <para> /// Example: /// <code> /// Book cBook = new Book(); /// cBook.SetTitle(Book.BOOK_TYPE_C); /// cBook.SetDescription("c_description"); /// cBook.SetAuthor("c_author"); /// cBook.SetLink("c_link"); /// /// DatabaseDescriptor databaseDescriptor = cBook.GetDatabaseDescriptor(); /// /// try { /// Database.BeginTransaction(databaseDescriptor); /// /// cBook.Save(); /// /// Database.CommitTransaction(databaseDescriptor); /// } catch(DatabaseException de) { /// //Log it. /// } finally { /// Database.EndTransaction(databaseDescriptor); /// } /// </code> /// </para> /// </summary> /// <param name="databaseDescriptor">Database Descriptor Object</param> public static void EndTransaction(DatabaseDescriptor databaseDescriptor) { DatabaseHelper.EndTransaction(databaseDescriptor); }
/// <summary> /// Removes database bundle instance /// </summary> /// <param name="databaseDescriptor">Database descriptor instance object</param> public void RemoveDatabaseBundle(DatabaseDescriptor databaseDescriptor) { this.databaseBundles.Remove(databaseDescriptor.GetDatabaseName()); }
public void Close(DatabaseDescriptor databaseDescriptor) { sqliteDatabase.Close(); }
public LocalizationsLoader(DatabaseDescriptor database) { Database = database; }
public IEnumerator <IDictionary <String, Object> > ExecuteSelectQuery(DatabaseDescriptor databaseDescriptor, EntityDescriptor entityDescriptor, String query) { #if XAMARIN SQLitePCL.sqlite3_stmt statement = SQLite3.Prepare2(sqliteDatabase.Handle, query); #elif WINDOWS List <SQLiteQueryRow> statement = null; #endif try { #if XAMARIN statement = SQLite3.Prepare2(sqliteDatabase.Handle, query); #elif WINDOWS statement = sqliteDatabase.Query2(query); #endif } catch (System.Exception exception) { if (sqliteDatabase.IsInTransaction) { sqliteDatabase.Rollback(); } Log.Log.Error(typeof(Database).FullName, "ExecuteSelectQuery", "Exception caught while executing the select query, QUERY: " + query); throw new DatabaseException(typeof(Database).FullName, "ExecuteSelectQuery", exception.Message); } List <Dictionary <String, Object> > tuples = new List <Dictionary <String, Object> >(); #if XAMARIN SQLite3.Result result; while ((result = SQLite3.Step(statement)) == SQLite3.Result.Row) { IDictionary <String, Object> tuple = new Dictionary <String, Object>(); String stmtResult = result.ToString(); //string[] names = SQLite3.ColType.GetNames (); //string[] values = SQLite3.ColType.GetValues (); int columnsCount = SQLite3.ColumnCount(statement); for (int i = 0; i < columnsCount; i++) { String columnName = SQLite3.ColumnName(statement, i); SQLite3.ColType columnType = SQLite3.ColumnType(statement, i); Object columnValue = SQLite3.ColumnText(statement, i); bool isString = false; bool isLong = false; bool isFloat = false; bool isBlob = false; if (columnType == SQLite3.ColType.Text) { isString = true; } else if (columnType == SQLite3.ColType.Integer) { isLong = true; } else if (columnType == SQLite3.ColType.Float) { isFloat = true; } else if (columnType == SQLite3.ColType.Blob) { isBlob = true; } else if (columnType == SQLite3.ColType.Null) { } if (isString) { if (entityDescriptor != null) { EntityDescriptor.Attribute attribute = entityDescriptor.GetAttributeBasedOnColumnName(columnName); if (attribute != null) { if (attribute.GetType().Equals(IDataTypeHandler.CSHARP_STRING_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, (String)columnValue); } else if (attribute.GetType().Equals(IDataTypeHandler.CSHARP_BOOLEAN_PRIMITIVE_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue.Equals(Boolean.TrueString.ToString()) ? true : false); } else if (attribute.GetType().Equals(IDataTypeHandler.CSHARP_BOOLEAN_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue.Equals(Boolean.TrueString.ToString()) ? Boolean.TrueString : Boolean.FalseString); } else if (attribute.GetType().Equals(IDataTypeHandler.JAVASCRIPT_STRING_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, (String)columnValue); } } else { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else if (isLong) { if (entityDescriptor != null) { EntityDescriptor.Attribute attribute = entityDescriptor.GetAttributeBasedOnColumnName(columnName); if (attribute != null) { if (attribute.GetType().Equals(IDataTypeHandler.JAVASCRIPT_NUMBER_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else if (isFloat) { if (entityDescriptor != null) { EntityDescriptor.Attribute attribute = entityDescriptor.GetAttributeBasedOnColumnName(columnName); if (attribute != null) { if (attribute.GetType().Equals(IDataTypeHandler.JAVASCRIPT_NUMBER_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } tuple.Add(columnName, columnValue); } else if (isBlob) { tuple.Add(columnName, columnValue); } } tuples.Add((Dictionary <String, Object>)tuple); } SQLite3.Finalize(statement); return(tuples.GetEnumerator()); #elif WINDOWS foreach (SQLiteQueryRow cursor in statement) { IDictionary <String, Object> tuple = new Dictionary <String, Object>(); List <SQLiteQueryColumn> columns = cursor.column; if (columns == null || columns.Count <= 0) { continue; } foreach (SQLiteQueryColumn column in columns) { String columnName = column.Key; Object columnValue = column.Value; bool isString = false; bool isLong = false; bool isFloat = false; bool isBlob = false; if (columnValue != null) { if (columnValue.GetType().FullName.Equals(typeof(String).FullName, StringComparison.OrdinalIgnoreCase)) { isString = true; } else if (columnValue.GetType().FullName.Equals(typeof(long).FullName, StringComparison.OrdinalIgnoreCase)) { isLong = true; } else if (columnValue.GetType().FullName.Equals(typeof(float).FullName, StringComparison.OrdinalIgnoreCase)) { isFloat = true; } else if (columnValue.GetType().FullName.Equals(typeof(byte).FullName, StringComparison.OrdinalIgnoreCase)) { isBlob = true; } } else { isString = true; } if (isString) { if (entityDescriptor != null) { EntityDescriptor.Attribute attribute = entityDescriptor.GetAttributeBasedOnColumnName(columnName); if (attribute != null) { if (attribute.GetType().Equals(IDataTypeHandler.CSHARP_STRING_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, (String)columnValue); } else if (attribute.GetType().Equals(IDataTypeHandler.CSHARP_BOOLEAN_PRIMITIVE_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue.Equals(Boolean.TrueString.ToString()) ? true : false); } else if (attribute.GetType().Equals(IDataTypeHandler.CSHARP_BOOLEAN_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue.Equals(Boolean.TrueString.ToString()) ? Boolean.TrueString : Boolean.FalseString); } else if (attribute.GetType().Equals(IDataTypeHandler.JAVASCRIPT_STRING_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, (String)columnValue); } } else { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else if (isLong) { if (entityDescriptor != null) { EntityDescriptor.Attribute attribute = entityDescriptor.GetAttributeBasedOnColumnName(columnName); if (attribute != null) { if (attribute.GetType().Equals(IDataTypeHandler.JAVASCRIPT_NUMBER_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else if (isFloat) { if (entityDescriptor != null) { EntityDescriptor.Attribute attribute = entityDescriptor.GetAttributeBasedOnColumnName(columnName); if (attribute != null) { if (attribute.GetType().Equals(IDataTypeHandler.JAVASCRIPT_NUMBER_DATA_TYPE, StringComparison.OrdinalIgnoreCase)) { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } } else { tuple.Add(columnName, columnValue); } tuple.Add(columnName, columnValue); } else if (isBlob) { tuple.Add(columnName, columnValue); } } tuples.Add((Dictionary <String, Object>)tuple); } return(tuples.GetEnumerator()); #endif }
/// <summary> /// Begins a transaction in EXCLUSIVE mode. /// <para> /// Transactions can be nested. When the outer transaction is ended all of the work done in that transaction and all of the nested transactions will be committed or rolled back. /// The changes will be rolled back if any transaction is ended without being marked as clean(by calling commitTransaction). Otherwise they will be committed. /// <code> /// Book cBook = new Book(); /// cBook.SetTitle(Book.BOOK_TYPE_C); /// cBook.SetDescription("c_description"); /// cBook.SetAuthor("c_author"); /// cBook.SetLink("c_link"); /// /// DatabaseDescriptor databaseDescriptor = cBook.GetDatabaseDescriptor(); /// /// try { /// Database.BeginTransaction(databaseDescriptor); /// /// cBook.Save(); /// /// Database.CommitTransaction(databaseDescriptor); /// } catch(DatabaseException de) { /// //Log it. /// } finally { /// Database.EndTransaction(databaseDescriptor); /// } /// </code> /// </para> /// </summary> /// <param name="databaseDescriptor">Database Descriptor Object</param> /// <exception cref="Siminov.Core.ExceptionDatabaseException">If beginTransaction does not starts</exception> public static void BeginTransaction(DatabaseDescriptor databaseDescriptor) { DatabaseHelper.BeginTransaction(databaseDescriptor); }
/// <summary> /// Get IDatabase object based on Database Descriptor name. /// </summary> /// <param name="databaseName">Name of Database Descriptor</param> /// <returns>IDatabase object</returns> public DatabaseBundle GetDatabaseBundle(String databaseName) { DatabaseDescriptor databaseDescriptor = GetDatabaseDescriptorBasedOnName(databaseName); return(this.databaseFactory.GetDatabaseBundle(databaseDescriptor)); }
/// <summary> /// Remove IDatabase object from Resources based on Database Descriptor name. /// </summary> /// <param name="databaseDescriptorName">Database Descriptor name</param> public void RemoveDatabaseBundle(String databaseDescriptorName) { DatabaseDescriptor databaseDescriptor = GetDatabaseDescriptorBasedOnName(databaseDescriptorName); this.databaseFactory.RemoveDatabaseBundle(databaseDescriptor); }
/// <summary> /// It process all DatabaseDescriptor.xml and initialize Database and stores in Resource Manager. /// </summary> protected static void ProcessDatabase() { ApplicationDescriptor applicationDescriptor = coreResourceManager.GetApplicationDescriptor(); IEnumerator <DatabaseDescriptor> databaseDescriptors = applicationDescriptor.GetDatabaseDescriptors(); while (databaseDescriptors.MoveNext()) { DatabaseDescriptor databaseDescriptor = databaseDescriptors.Current; String databasePath = new DatabaseUtils().GetDatabasePath(databaseDescriptor); DatabaseBundle databaseBundle = null; try { databaseBundle = DatabaseHelper.CreateDatabase(databaseDescriptor); } catch (DatabaseException databaseException) { Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while getting database instance from database factory, DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } IDatabaseImpl database = databaseBundle.GetDatabase(); IQueryBuilder queryBuilder = databaseBundle.GetQueryBuilder(); /* * If Database exists then open and return. * If Database does not exists create the database. */ String databaseName = databaseDescriptor.GetDatabaseName(); if (!databaseName.EndsWith(".db")) { databaseName = databaseName + ".db"; } bool fileExists = FileUtils.DoesFileExists(databasePath, databaseName, FileUtils.LOCAL_FOLDER); if (fileExists) { /* * Open Database */ try { database.OpenOrCreate(databaseDescriptor); } catch (DatabaseException databaseException) { Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while opening database, " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } /* * Enable Foreign Key Constraints */ try { database.ExecuteQuery(databaseDescriptor, null, Constants.SQLITE_DATABASE_QUERY_TO_ENABLE_FOREIGN_KEYS_MAPPING); } catch (DatabaseException databaseException) { FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER); Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while executing query to enable foreign keys, " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } /* * Safe MultiThread Transaction */ /*try * { * database.ExecuteMethod(Constants.SQLITE_DATABASE_ENABLE_LOCKING, databaseDescriptor.IsTransactionSafe()); * } * catch (DatabaseException databaseException) * { * FileUtils.DoesFileExists(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER); * * Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while enabling locking on database, " + databaseException.GetMessage()); * throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); * }*/ /* * Upgrade Database */ try { DatabaseHelper.UpgradeDatabase(databaseDescriptor); } catch (DatabaseException databaseException) { Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while upgrading database, " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } } else { /* * Create Database Directory */ try { FileUtils.GetFolder(databasePath, FileUtils.LOCAL_FOLDER); } catch (System.Exception exception) { Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "Exception caught while creating database directories, DATABASE-PATH: " + databasePath + ", DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName() + ", " + exception.Message); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", exception.Message); } /* * Create Database File. */ try { database.OpenOrCreate(databaseDescriptor); } catch (DatabaseException databaseException) { FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER); Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while creating database, " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } /* * Set Database Version */ IDictionary <String, Object> parameters = new Dictionary <String, Object>(); parameters.Add(IQueryBuilder.FORM_UPDATE_DATABASE_VERSION_QUERY_DATABASE_VERSION_PARAMETER, databaseDescriptor.GetVersion()); try { String updateDatabaseVersionQuery = queryBuilder.FormUpdateDatabaseVersionQuery(parameters); database.ExecuteQuery(databaseDescriptor, null, updateDatabaseVersionQuery); } catch (DatabaseException databaseException) { Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "Database Exception caught while updating database version, " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } IDatabaseEvents databaseEventHandler = coreResourceManager.GetDatabaseEventHandler(); if (databaseEventHandler != null) { databaseEventHandler.OnDatabaseCreated(databaseDescriptor); } /* * Enable Foreign Key Constraints */ try { database.ExecuteQuery(databaseDescriptor, null, Constants.SQLITE_DATABASE_QUERY_TO_ENABLE_FOREIGN_KEYS_MAPPING); } catch (DatabaseException databaseException) { FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER); Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while executing query to enable foreign keys, " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } /* * Safe MultiThread Transaction */ /*try * { * database.ExecuteMethod(Constants.SQLITE_DATABASE_ENABLE_LOCKING, databaseDescriptor.IsTransactionSafe()); * } * catch (DatabaseException databaseException) * { * FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER); * * Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while enabling locking on database, " + databaseException.GetMessage()); * throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); * }*/ /* * Create Tables */ try { DatabaseHelper.CreateTables(databaseDescriptor.OrderedEntityDescriptors()); } catch (DatabaseException databaseException) { FileUtils.DeleteFile(databasePath, databaseDescriptor.GetDatabaseName(), FileUtils.LOCAL_FOLDER); Log.Log.Error(typeof(Siminov).FullName, "ProcessDatabase", "DatabaseException caught while creating tables, " + databaseException.GetMessage()); throw new DeploymentException(typeof(Siminov).FullName, "ProcessDatabase", databaseException.GetMessage()); } } } }