/// <summary> /// Remove Database Descriptor from Resources based on database path provided, as per defined in ApplicationDescriptor.xml file /// </summary> /// <param name="databaseDescriptorPath">Database Descriptor Path</param> public void RemoveDatabaseDescriptorBasedOnPath(String databaseDescriptorPath) { this.databaseDescriptorPaths.Remove(databaseDescriptorPath); DatabaseDescriptor databaseDescriptor = this.databaseDescriptorsBasedOnPath[databaseDescriptorPath]; this.databaseDescriptorsBasedOnPath.Remove(databaseDescriptorPath); this.databaseDescriptorsBasedOnName.Values.Remove(databaseDescriptor); }
/// <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 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> /// Remove Database Descriptor from Resources based in database name provided, as per defined in DatabaseDescriptor.xml file /// </summary> /// <param name="databaseDescriptorName">DatabaseDescriptor Name</param> public void RemoveDatabaseDescriptorBasedOnName(String databaseDescriptorName) { DatabaseDescriptor databaseDescriptor = this.databaseDescriptorsBasedOnName[databaseDescriptorName]; ICollection <String> keys = this.databaseDescriptorsBasedOnPath.Keys; String keyMatched = null; bool found = false; foreach (String key in keys) { DatabaseDescriptor descriptor = this.databaseDescriptorsBasedOnPath[key]; if (databaseDescriptor == descriptor) { keyMatched = key; found = true; break; } } if (found) { RemoveDatabaseDescriptorBasedOnPath(keyMatched); } }
/// <summary> /// Remove DatabaseDescriptor object from Resources. /// </summary> /// <param name="databaseDescriptor">DatabaseDescriptor object which needs to be removed</param> public void RemoveDatabaseDescriptor(DatabaseDescriptor databaseDescriptor) { RemoveDatabaseDescriptorBasedOnName(databaseDescriptor.GetDatabaseName()); }
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); } }
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> /// Add Database Descriptor object in respect to database descriptor path. /// </summary> /// <param name="databaseDescriptorPath">Database Descriptor Path</param> /// <param name="databaseDescriptor">Database Descriptor Object</param> public void AddDatabaseDescriptor(String databaseDescriptorPath, DatabaseDescriptor databaseDescriptor) { this.databaseDescriptorsBasedOnPath.Add(databaseDescriptorPath, databaseDescriptor); this.databaseDescriptorsBasedOnName.Add(databaseDescriptor.GetDatabaseName(), 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()); }
/// <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> /// 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> /// 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 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 ""; }
/// <summary> /// Check whether database descriptor exists in Resources or not. /// </summary> /// <param name="databaseDescriptor">Database Descriptor object</param> /// <returns>TRUE: If Database Descriptor exists in Resources, FALSE: If Database Descriptor does not exists in Resources.</returns> public bool ContainsDatabaseDescriptor(DatabaseDescriptor databaseDescriptor) { return(this.databaseDescriptorsBasedOnName.Values.Contains(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) { Siminov.IsActive(); /* * 1. Get entity descriptor object for mapped invoked class object. */ DatabaseBundle databaseBundle = resourceManager.GetDatabaseBundle(databaseDescriptor.GetDatabaseName()); IDatabaseImpl database = databaseBundle.GetDatabase(); if (database == null) { Log.Log.Error(typeof(DatabaseHelper).FullName, "CommitTransaction", "No Database Instance Found For DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); throw new DeploymentException(typeof(DatabaseHelper).FullName, "CommitTransaction", "No Database Instance Found For DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); } try { database.ExecuteMethod(Constants.SQLITE_DATABASE_END_TRANSACTION, null); } catch (DatabaseException databaseException) { Log.Log.Error(typeof(DatabaseHelper).FullName, "CommitTransaction", "DatabaseException caught while executing end transaction method, " + databaseException.GetMessage()); } }
/// <summary> /// It is used to create instance of IDatabase implementation /// </summary> /// <param name="databaseDescriptor">Database Bundle instance object</param> /// <returns>DatabaseBundle</returns> /// <exception cref="Siminov.Core.Exception.DatabaseException"></exception> public static DatabaseBundle CreateDatabase(DatabaseDescriptor databaseDescriptor) { return DatabaseFactory.GetInstance().GetDatabaseBundle(databaseDescriptor); }
/// <summary> /// Upgrade Existing Database /// </summary> /// <param name="databaseDescriptor">Database Descriptor Object</param> /// <exception cref="Siminov.Core.Exception.DatabaseException">throws If any exception thrown</exception> public static void UpgradeDatabase(DatabaseDescriptor databaseDescriptor) { DatabaseBundle databaseBundle = resourceManager.GetDatabaseBundle(databaseDescriptor.GetDatabaseName()); IDatabaseImpl database = databaseBundle.GetDatabase(); IQueryBuilder queryBuilder = databaseBundle.GetQueryBuilder(); if (database == null) { Log.Log.Error(typeof(DatabaseHelper).FullName, "UpgradeDatabase", "No Database Instance Found For, DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); throw new DatabaseException(typeof(DatabaseHelper).FullName, "UpgradeDatabase", "No Database Instance Found For, DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); } /* * Fetch Database Version */ String fetchDatabaseVersionQuery = queryBuilder.FormFetchDatabaseVersionQuery(null); Log.Log.Debug(typeof(DatabaseHelper).FullName, "UpgradeDatabase", "Fetch Database Version Query: " + fetchDatabaseVersionQuery); double currentDatabaseVersion = 0; IEnumerator<IDictionary<String, Object>> datas = database.ExecuteSelectQuery(databaseDescriptor, null, fetchDatabaseVersionQuery); while (datas.MoveNext()) { IDictionary<String, Object> data = datas.Current; ICollection<Object> parse = data.Values; IEnumerator<Object> values = parse.GetEnumerator(); while (values.MoveNext()) { Object value = values.Current; if (value.GetType().FullName.Equals(typeof(String).FullName, StringComparison.OrdinalIgnoreCase)) { currentDatabaseVersion = Double.Parse((String)value); } else if (value.GetType().FullName.Equals(typeof(Double).FullName, StringComparison.OrdinalIgnoreCase)) { currentDatabaseVersion = (double)value; } } } if (currentDatabaseVersion == databaseDescriptor.GetVersion()) { return; } ICollection<EntityDescriptor> allEntityDescriptor = new List<EntityDescriptor>(); IEnumerator<EntityDescriptor> allEntityDescriptorIterator = resourceManager.GetEntityDescriptors(); while (allEntityDescriptorIterator.MoveNext()) { allEntityDescriptor.Add(allEntityDescriptorIterator.Current); } ICollection<String> tableNames = new List<String>(); IEnumerator<EntityDescriptor> entityDescriptors = databaseDescriptor.GetEntityDescriptors(); /* * Get Table Names */ String fetchTableNamesQuery = queryBuilder.FormTableNames(null); Log.Log.Debug(typeof(DatabaseHelper).FullName, "UpgradeDatabase", "Fetch Table Names, " + fetchTableNamesQuery); datas = database.ExecuteSelectQuery(databaseDescriptor, null, fetchTableNamesQuery); while (datas.MoveNext()) { IDictionary<String, Object> data = datas.Current; IEnumerator<String> keys = data.Keys.GetEnumerator(); while (keys.MoveNext()) { String key = keys.Current; if (key.Equals(Constants.FORM_TABLE_NAMES_NAME, StringComparison.OrdinalIgnoreCase)) { tableNames.Add((String)data[key]); } } } /* * Create Or Upgrade Table */ while (entityDescriptors.MoveNext()) { EntityDescriptor entityDescriptor = entityDescriptors.Current; bool contain = false; foreach (String tableName in tableNames) { if (tableName.Equals(entityDescriptor.GetTableName(), StringComparison.OrdinalIgnoreCase)) { contain = true; break; } } if (contain) { DatabaseHelper.UpgradeTable(entityDescriptor); } else { DatabaseHelper.CreateTable(entityDescriptor); } } /* * Drop Table */ foreach (String tableName in tableNames) { if (tableName.Equals(Constants.ANDROID_METADATA_TABLE_NAME, StringComparison.OrdinalIgnoreCase)) { continue; } bool contain = false; foreach (EntityDescriptor entityDescriptor in allEntityDescriptor) { if (tableName.Equals(entityDescriptor.GetTableName(), StringComparison.OrdinalIgnoreCase)) { contain = true; break; } } if (!contain) { IDictionary<String, Object> childParameters = new Dictionary<String, Object>(); childParameters.Add(IQueryBuilder.FORM_DROP_TABLE_QUERY_TABLE_NAME_PARAMETER, tableName); database.ExecuteQuery(databaseDescriptor, null, queryBuilder.FormDropTableQuery(childParameters)); } } /* * Update Database Version */ IDictionary<String, Object> parameters = new Dictionary<String, Object>(); parameters.Add(IQueryBuilder.FORM_UPDATE_DATABASE_VERSION_QUERY_DATABASE_VERSION_PARAMETER, databaseDescriptor.GetVersion()); String updateDatabaseVersionQuery = queryBuilder.FormUpdateDatabaseVersionQuery(parameters); Log.Log.Debug(typeof(DatabaseHelper).FullName, "UpgradeDatabase", "Update Database Version Query: " + updateDatabaseVersionQuery); database.ExecuteQuery(databaseDescriptor, null, updateDatabaseVersionQuery); }
/// <summary> /// It drop's the whole database based on database-descriptor /// <para> /// Drop the Book table /// <code> /// DatabaseDescriptor databaseDescriptor = new Book().GetDatabaseDescriptor(); /// /// try { /// Database.DropDatabase(databaseDescriptor); /// } catch(DatabaseException databaseException) { /// //Log It. /// } /// </code> /// </para> /// </summary> /// <param name="databaseDescriptor">Database Descriptor object which defines the structure of table</param> /// <exception cref="Siminov.Core.Exception.DatabaseException">If not able to drop database</exception> public static void DropDatabase(DatabaseDescriptor databaseDescriptor) { Siminov.IsActive(); DatabaseBundle databaseBundle = resourceManager.GetDatabaseBundle(databaseDescriptor.GetDatabaseName()); IDatabaseImpl database = databaseBundle.GetDatabase(); if (database == null) { Log.Log.Error(typeof(DatabaseHelper).FullName, "DropDatabase", "No Database Instance Found For DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); throw new DeploymentException(typeof(DatabaseHelper).FullName, "DropDatabase", "No Database Instance Found For DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); } String databasePath = new DatabaseUtils().GetDatabasePath(databaseDescriptor); database.Close(databaseDescriptor); String databaseName = databaseDescriptor.GetDatabaseName(); if (!databaseName.EndsWith(".db")) { databaseName = databaseName + ".db"; } FileUtils.DeleteFile(databasePath, databaseName, FileUtils.LOCAL_FOLDER); resourceManager.RemoveDatabaseBundle(databaseDescriptor.GetDatabaseName()); IDatabaseEvents databaseEventHandler = resourceManager.GetDatabaseEventHandler(); if (databaseEventHandler != null) { databaseEventHandler.OnDatabaseDropped(databaseDescriptor); } }
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> /// Marks the current transaction as successful /// <para> /// Finally it will End a transaction /// Example: Make Book Object /// <code> /// Book cBook = new Book(); /// cBook.SetTitle(Book.BOOK_TYPE_C); /// cBook.SetDescription("c_description"); /// cBook.SetHistory("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="Siminiov.Core.Exception.DatabaseException">If not able to commit the transaction</exception> public static void CommitTransaction(DatabaseDescriptor databaseDescriptor) { Siminov.IsActive(); if(databaseDescriptor.IsTransactionSafe()) { transactionSafe.Release(); } /* * 1. Get entity descriptor object for mapped invoked class object. */ DatabaseBundle databaseBundle = resourceManager.GetDatabaseBundle(databaseDescriptor.GetDatabaseName()); IDatabaseImpl database = databaseBundle.GetDatabase(); if (database == null) { Log.Log.Error(typeof(DatabaseHelper).FullName, "CommitTransaction", "No Database Instance Found For DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); throw new DeploymentException(typeof(DatabaseHelper).FullName, "CommitTransaction", "No Database Instance Found For DATABASE-DESCRIPTOR: " + databaseDescriptor.GetDatabaseName()); } database.ExecuteMethod(Constants.SQLITE_DATABASE_COMMIT_TRANSACTION, null); }
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> /// Check whether database descriptor exists in Resources or not. /// </summary> /// <param name="databaseDescriptor">Database Descriptor object</param> /// <returns>TRUE: If Database Descriptor exists in Resources, FALSE: If Database Descriptor does not exists in Resources.</returns> public bool ContainsDatabaseDescriptor(DatabaseDescriptor databaseDescriptor) { return this.databaseDescriptorsBasedOnName.Values.Contains(databaseDescriptor); }
public void Close(DatabaseDescriptor databaseDescriptor) { sqliteDatabase.Close(); }
/// <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; }