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