//#region "Initialize/close"
/// <summary>
/// Initializes the database connection
/// </summary>
public async Task InitializeDatabaseAsync()
{
//Create table schema if doesn't exist.
//Note that is non-destructive and should not drop tables if they are already there
await AsyncConnection.CreateTableAsync <DatabaseObjects.BankAccount>();
await AsyncConnection.CreateTableAsync <DatabaseObjects.BankAccountTransaction>();
int bankAccountCount = await AsyncConnection.Table <DatabaseObjects.BankAccount>().CountAsync();
Log.ConsoleInfo(string.Format("seconomy: {0} clean - {1} accounts", _path, bankAccountCount));
_ready = true;
/*
* return AsyncConnection.CreateTableAsync<DatabaseObjects.BankAccount>().ContinueWith((i) => {
* AsyncConnection.CreateTableAsync<DatabaseObjects.BankAccountTransaction>().ContinueWith((x) => {
* AsyncConnection.Table<DatabaseObjects.BankAccount>().CountAsync().ContinueWith((count) => {
* int bankAccountCount = count.Result;
* Log.ConsoleInfo(string.Format("seconomy: {0} clean - {1} accounts", _path, bankAccountCount));
*
* _ready = true;
* });
* });
* });
*/
}
public async Task <bool> DeleteFromDBAsync(FreeDiscItemDownload freeDiscDownloader)
{
if (freeDiscDownloader == null)
{
#if DEBUG
Debug.Write("DeleteFromDBAsync: freeDiscDownloader == null");
#endif
return(false);
}
#if DEBUG
Debug.Write("DeleteFromDB: ID" + freeDiscDownloader.DBID + " Title: " + freeDiscDownloader?.Title + " Status: " + freeDiscDownloader?.ItemStatus.ToString());
#endif
if (freeDiscDownloader.DBID == 0)
{
#if DEBUG
Debug.Write("DeleteFromDB: freeDiscDownloader.DBID == 0 !");
#endif
return(false);
}
try
{
var conn = new SQLite.SQLiteAsyncConnection(App.AppSetting.DBDownloadPath);
await conn.CreateTableAsync <FreeDiscItemDownload>();
await conn.DeleteAsync(freeDiscDownloader);
}
catch (Exception e)
{
#if DEBUG
Debug.Write("DeleteFromDB: Delete error ! : " + e.ToString());
#endif
return(false);
}
return(true);
}
private async void Create()
{
Connection = new SQLiteAsyncConnection(dbpath);
// create all tables
Connection.CreateTableAsync<SQLite.Task>();
}
public async Task <bool> SaveToDBAsync(FreeDiscItemDownload freeDiscDownloader)
{
if (freeDiscDownloader == null)
{
#if DEBUG
Debug.Write("SaveToDBAsync: freeDiscDownloader == null");
#endif
return(false);
}
#if DEBUG
Debug.Write("SaveToDB: ID" + freeDiscDownloader.DBID + " Title: " + freeDiscDownloader?.Title + " Status: " + freeDiscDownloader?.ItemStatus.ToString());
#endif
try
{
var conn = new SQLite.SQLiteAsyncConnection(App.AppSetting.DBDownloadPath);
await conn.CreateTableAsync <FreeDiscItemDownload>();
await conn.InsertAsync(freeDiscDownloader);
}
catch (Exception e)
{
#if DEBUG
Debug.Write("SaveToDB: Save error !");
#endif
return(false);
}
#if DEBUG
Debug.Write("SaveToDB: Result ID" + freeDiscDownloader?.DBID ?? "NULL");
#endif
return(true);
}
public async static void CheckAndCreateDatabase()
{
if (!await FileUtils.CheckFileExists(DbHelper.DB_NAME))
{
System.Diagnostics.Debug.WriteLine("creating tables");
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(DB_PATH);
await conn.CreateTableAsync<Organization>();
await conn.CreateTableAsync<Counter>();
await conn.CreateTableAsync<Menu>();
await conn.CreateTableAsync<Item>();
}
else
{
System.Diagnostics.Debug.WriteLine("tables exist");
}
}
private async void loadData()
{
//SQLiteAsyncConnection conn1 = new SQLiteAsyncConnection(System.IO.Path.Combine(ApplicationData.Current.LocalFolder.Path, "Appointment.db"), true);
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(System.IO.Path.Combine(ApplicationData.Current.LocalFolder.Path, "Appointment.db"), true);
conn.DropTableAsync<SampleAppointment>();
await conn.CreateTableAsync<SampleAppointment>();
DateTime temp = DateTime.Now;
DateTime start = DateTime.Parse("06/08/2013 6:00 PM");
DateTime end = DateTime.Parse("06/09/2013 6:00 PM");
SampleAppointment appointment1 = new SampleAppointment
{
Subject = "MACF - App Camp",
AdditionalInfo = "BRTN 291, RSVP Reguired",
StartDate = start,
EndDate = end
};
conn.InsertAsync(appointment1);
SampleAppointment appointment2 = new SampleAppointment
{
StartDate = DateTime.Now.AddMinutes(30),
EndDate = DateTime.Now.AddHours(1),
Subject = "Appointment 376",
AdditionalInfo = "Info 3"
};
conn.InsertAsync(appointment2);
start = DateTime.Parse("06/05/2013 5:00 PM");
end = DateTime.Parse("06/05/2013 6:00 PM");
SampleAppointment appointment3 = new SampleAppointment
{
StartDate = DateTime.Now.AddHours(2),
EndDate = DateTime.Now.AddHours(3),
Subject = "Appointment uhy4",
AdditionalInfo = "Info 4"
};
conn.InsertAsync(appointment3);
SampleAppointment appointment4 = new SampleAppointment
{
Subject = "Malaysian Night",
AdditionalInfo = "STEW Common, Members Only",
StartDate = start,
EndDate = end
};
conn.InsertAsync(appointment4);
//this.OnDataLoaded();
}
public StationRepository()
{
string DbFilePath = Path.Combine(
System.Environment.GetFolderPath(
System.Environment.SpecialFolder.LocalApplicationData), "NorthWind.db");
Database = new SQLiteAsyncConnection(DbFilePath);
Database.CreateTableAsync <Entities.Station>().Wait();
var Station1 = new Data.Entities.Station
{
ID = 1,
Name = "1",
Description = "EB - Central",
Address = "1",
Phone = "2739293",
Lat = "1",
Lng = "1"
};
var Station2 = new Data.Entities.Station
{
ID = 2,
Name = "2",
Description = "EB - Chapinero",
Address = "2",
Phone = "2839475",
Lat = "2",
Lng = "2"
};
var Station3 = new Data.Entities.Station
{
ID = 3,
Name = "3",
Description = "EB - Restrepo",
Address = "3",
Phone = "8938495",
Lat = "3",
Lng = "3"
};
var Station4 = new Data.Entities.Station
{
ID = 4,
Name = "4",
Description = "EB - Las Ferias",
Address = "4",
Phone = "1267384",
Lat = "4",
Lng = "4"
};
CreateStationAsync(Station1);
CreateStationAsync(Station2);
CreateStationAsync(Station3);
CreateStationAsync(Station4);
}
async Task<int> connectDB()
{
var path = Windows.Storage.ApplicationData.Current.LocalFolder.Path + @"\beyondvincent.db";
db = new SQLiteAsyncConnection(path);
await db.DropTableAsync<User>();
await db.CreateTableAsync<User>();
return 0;
}
public async void CreateDatabase()
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(Path.Combine(ApplicationData.Current.LocalFolder.Path, "User.db"), true);
await conn.CreateTableAsync<User>();
SQLiteAsyncConnection conn1 = new SQLiteAsyncConnection(Path.Combine(ApplicationData.Current.LocalFolder.Path, "Appointment.db"), true);
await conn1.CreateTableAsync<Appointment>();
}
public App (string dbPath)
{
// set up the database
db = new SQLiteAsyncConnection (dbPath);
db.CreateTableAsync<TaskItem> ().Wait ();
// The root page of your application
MainPage = new NavigationPage (new TasksPage (db));
}
public UserInfoRepository()
{
string DbFilePath = Path.Combine(
System.Environment.GetFolderPath(
System.Environment.SpecialFolder.LocalApplicationData), "NorthWind.db");
Database = new SQLiteAsyncConnection(DbFilePath);
Database.CreateTableAsync <Entities.UserInfo>().Wait();
}
public void UnicodePathsAsync()
{
var path = Path.GetTempFileName () + UnicodeText;
var db = new SQLiteAsyncConnection (path, true);
db.CreateTableAsync<OrderLine> ().Wait ();
Assert.That (new FileInfo (path).Length, Is.GreaterThan (0), path);
}
public async static Task<SQLiteAsyncConnection> ConnectToDatabase()
{
var databaseConnection = new SQLiteAsyncConnection(DatabaseFileName, SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.NoMutex);
var version = "1.3";
var oldVersion = ApplicationSettings.DatabaseCreationVersion.Read();
if (oldVersion != version)
{
await databaseConnection.CreateTableAsync<Song>();
await databaseConnection.CreateTableAsync<SongGenre>();
await databaseConnection.CreateTableAsync<Genre>();
await databaseConnection.CreateTableAsync<CachedAlbumCover>();
await databaseConnection.CreateTableAsync<CurrentPlaylistSong>();
await databaseConnection.CreateTableAsync<SavedPlaylistSong>();
await databaseConnection.CreateTableAsync<SavedPlaylist>();
necessaryUpdatesForLibrary = new List<Func<MusicLibrary, Task>>();
ApplicationSettings.IsDatabaseSettingUp.Save(true);
if (oldVersion == "1.0" || oldVersion == "1.1" || oldVersion == "1.3")
{
necessaryUpdatesForLibrary.Add(async library =>
{
foreach (var song in library.Songs)
{
try
{
var storageFile = await StorageFile.GetFileFromPathAsync(song.FileName);
TagLib.Tag tag = null;
using (var stream = await storageFile.OpenStreamForReadAsync())
{
tag = await Task<TagLib.File>.Run(() =>
{
try
{
return TagLib.File.Create(new TagLib.StreamFileAbstraction(storageFile.Name, stream, null)).Tag;
}
catch { return null; }
});
}
if (tag != null)
{
library.localLibrarySource.UpdateSongMetadata(tag, song);
await library.databaseConnection.UpdateAsync(song);
}
}
catch { }
}
});
}
necessaryUpdatesForLibrary.Add(async library => { ApplicationSettings.DatabaseCreationVersion.Save(version); await Task.Delay(0); });
}
return databaseConnection;
}
public ProductRepository()
{
string DbFilePath = Path.Combine(
Environment.GetFolderPath(
Environment.SpecialFolder.LocalApplicationData),
"NorthWind.db");
_database = new SQLiteAsyncConnection(DbFilePath);
_database.CreateTableAsync <Product>().Wait();
}
public static async void insertProduct(Product product)
{
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(PRODUCTS_TABLE);
await conn.CreateTableAsync<Product>();
await conn.InsertAsync(product);
}
private static async void createFavouritesTable()
{
String path = ApplicationData.Current.LocalFolder.Path + "/OCTranspo.sqlite";
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(path);
var count = await conn.ExecuteScalarAsync<int>("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='OCDirection'");
if (count == 0)
{
await conn.CreateTableAsync<OCDirection>();
}
}
public SQLiteAsyncConnection GetConnection()
{
var documentsPath = System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyDocuments);
//Se crea la Base de datos
var path = Path.Combine(documentsPath, "NorthWind.db");
_database = new SQLiteAsyncConnection(path);
_database.CreateTableAsync <Product>().Wait();
return(_database);
}
public static async Task<List<Exam>> getExamsAsync()
{
if (exams.Count != 0)
{
return exams;
}
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(Windows.Storage.ApplicationData.Current.LocalFolder.Path + "\\Data.db");
await conn.CreateTableAsync<Exam>();
exams = await conn.Table<Exam>().OrderBy(exam => exam.ExamTime).ToListAsync();
return exams;
}
public HouseImageCacheRepository ()
{
string folder = Environment.GetFolderPath (Environment.SpecialFolder.Personal);
db = new SQLiteAsyncConnection (System.IO.Path.Combine (folder, "houseImages.db"));
// db.DropTableAsync<HouseImages> ().ContinueWith (t => {
// Console.WriteLine ("Table Dropped!");
// });
db.CreateTableAsync<HouseImages>().ContinueWith (t => {
Console.WriteLine ("Table created!");
});
}
private void initExternalDB()
{
DBVersion dbVersion = null;
mDatabase.CreateTableAsync <DBVersion>().Wait();
var taskR = mDatabase.Table <DBVersion>().FirstOrDefaultAsync();
dbVersion = taskR.Result;
if (dbVersion == null || dbVersion.Version < 1)
{
dbVersion = new DBVersion();
initExternalDBStruct_v1(dbVersion);
}
if (dbVersion.Version < 2)
{
updateExternalDBStruct_v2(dbVersion);
}
}
private static async void createSettingsTable()
{
String path = ApplicationData.Current.LocalFolder.Path + "/OCTranspo.sqlite";
SQLiteAsyncConnection conn = new SQLiteAsyncConnection(path);
var count = await conn.ExecuteScalarAsync<int>("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='OCSettings'");
if (count == 0)
{
await conn.CreateTableAsync<OCSettings>();
OCSettings settings = OCSettings.newOCSettings(500);
settings.id = 1;
await conn.InsertAsync(settings);
}
}
private async Task<string> createDatabase(string path)
{
try
{
var connection = new SQLiteAsyncConnection(path);
await connection.CreateTableAsync<Person>();
return "Database created";
}
catch (SQLiteException ex)
{
return ex.Message;
}
}
private async void CreateDatabase ()
{
try
{
var connection = new SQLiteAsyncConnection (_path);
await connection.CreateTableAsync<UserVideo> ();
}
catch (SQLiteException ex)
{
Log.Error(TAG, ex.Message);
}
}
private async void Button_Click_1(object sender, RoutedEventArgs e)
{
try
{
var path = ApplicationData.Current.LocalFolder.Path + @"\Users.db";
var db = new SQLiteAsyncConnection(path);
await db.CreateTableAsync<User>();
}
catch (Exception)
{ }
//Button_Click_1.visibility = Visibility.Collapsed;
}
private async Task PrepareDatabase()
{
var path = Path.Combine(Path.GetDirectoryName(typeof(TodoService).Assembly.Location), "todos.db");
if (File.Exists(path))
File.Delete(path);
var db = new SQLiteAsyncConnection(path);
await db.CreateTableAsync<TodoItem>();
var count = await db.InsertAllAsync(Todos);
Assert.Equal(Todos.Count, count);
}
//-----------Database is created---------//
private string createDatabase(string path)
{
try
{
var connection = new SQLiteAsyncConnection(path);{
connection.CreateTableAsync<User>();
return "Database created";
}
}
catch (SQLiteException ex)
{
return ex.Message;
}
}
async void FnInitializeView()
{
FnStartActivityIndicator ();
sqlAsyncConnection = DbConnectionClass.FnGetConnection ();
tableViewContactsList.Hidden=true;
await sqlAsyncConnection.CreateTableAsync<PhoneContactClass> ();
var contactList=await FnGetAllContactList ();
FnStopActivityIndicator ();
FnBindContactList (contactList);
btnAddContact.SetBackgroundImage ( UIImage.FromBundle ( "Images/iconAdd" ) , UIControlState.Normal );
btnRefreshContactList.SetBackgroundImage ( UIImage.FromBundle ( "Images/iconRefreshImg" ) , UIControlState.Normal );
tableViewContactsList.Layer.CornerRadius = 10;
}
public async void InitWithPath(string dbFile, string dbTempDir)
{
_dbFile = dbFile;
_dbTempDir = dbTempDir;
try {
await ApplicationData.Current.LocalFolder.CreateFolderAsync(_dbTempDir);
}
catch (Exception) {} // exception thrown when folder already exists
_db = new SQLiteAsyncConnection(Path.Combine(ApplicationData.Current.LocalFolder.Path, _dbFile));
await _db.CreateTableAsync<CacheLine>();
}
public string createDB(string path)
{
try
{
var connection = new SQLiteAsyncConnection(System.IO.Path.Combine(path, "SQLiteTest.db"));
connection.CreateTableAsync<Person>().ContinueWith(t => {
Console.WriteLine("Table created!");
});
return "Table created!";
}
catch (SQLiteException ex)
{
return ex.Message;
}
}
void FnViewInitialize()
{
sqlAsyncConnection = DbConnectionClass.FnGetConnection ();
sqlAsyncConnection.CreateTableAsync<PhoneContactClass> ();
btnDeleteContact.Hidden = true;
if ( objPhoneContactClass != null )
{
txtContactName.Text = objPhoneContactClass.strContactName;
txtContactNumber.Text = objPhoneContactClass.strContactNumber.ToString();
btnDeleteContact.Hidden = false;
}
txtContactName.ShouldReturn += ( (textField ) => textField.ResignFirstResponder () );
txtContactNumber.ShouldReturn += ( (textField ) => textField.ResignFirstResponder () );
FnViewCustomization ();
}
private async void Init()
{
var db = new SQLite.SQLiteAsyncConnection(dbPath);
try
{
db.CreateTableAsync <Children>();
db.CreateTableAsync <EveryDay>();
db.CreateTableAsync <Reminder>();
db.CreateTableAsync <Vaccine>();
db.CreateTableAsync <Doctor>();
db.CreateTableAsync <Action>();
db.CreateTableAsync <Task>();
db.CreateTableAsync <Favorite>();
db.CreateTableAsync <Contact>();
}
catch (System.NullReferenceException e)
{
}
}
public void Create()
{
_sqLiteConnection = new SQLiteAsyncConnection(Constants.BaseDirectory + "analyzer.s3db");
_sqLiteConnection.CreateTableAsync<ChatLogEntry>()
.ContinueWith(results => LogHelper.Log(Logger, "ChatLogEntry Table Created", LogLevel.Trace));
_sqLiteConnection.CreateTableAsync<Encounter>()
.ContinueWith(results => LogHelper.Log(Logger, "Encounter Table Created", LogLevel.Trace));
_sqLiteConnection.CreateTableAsync<Events>()
.ContinueWith(results => LogHelper.Log(Logger, "Events Table Created", LogLevel.Trace));
_sqLiteConnection.CreateTableAsync<MonsterEntity>()
.ContinueWith(results => LogHelper.Log(Logger, "MonsterEntity Table Created", LogLevel.Trace));
_sqLiteConnection.CreateTableAsync<MonsterEntityUpdate>()
.ContinueWith(results => LogHelper.Log(Logger, "MonsterEntityUpdate Table Created", LogLevel.Trace));
_sqLiteConnection.CreateTableAsync<MonsterStatusEntry>()
.ContinueWith(results => LogHelper.Log(Logger, "MonsterStatusEntry Table Created", LogLevel.Trace));
_sqLiteConnection.CreateTableAsync<PartyMemberEntity>()
.ContinueWith(results => LogHelper.Log(Logger, "PartyMemberEntity Table Created", LogLevel.Trace));
_sqLiteConnection.CreateTableAsync<PartyMemberStatusEntry>()
.ContinueWith(results => LogHelper.Log(Logger, "PartyMemberStatusEntry Table Created", LogLevel.Trace));
}
public static async Task <SQLiteAsyncConnection> CreateCommDB()
{
var file = Path.Combine(SDKProperty.dbPath, "common.db");
if (!Directory.Exists(Path.GetDirectoryName(file)))
{
Directory.CreateDirectory(Path.GetDirectoryName(file));
}
//if (!File.Exists(file))
//{
// File.Create(file);
//}
var comconn = new SQLite.SQLiteAsyncConnection(file);
await comconn.CreateTableAsync <DB.historyAccountDB>();
return(comconn);
}
public static async Task<SQLiteAsyncConnection> CheckOrCreateStorage()
{
string dbPath = Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path, "RememberIt.sqlite");
SQLiteAsyncConnection dbConn = null;
if (!(await IsFileExist(dbPath.ToString())))
{
//新建并初始化数据库
dbConn = new SQLite.SQLiteAsyncConnection(dbPath);
//新建记忆项表
await dbConn.CreateTableAsync<RememberItem>();
//其他数据表
//...
}
else
{
//新建连接
dbConn = new SQLite.SQLiteAsyncConnection(dbPath);
}
return dbConn;
}
protected void InitializeDatabase()
{
var dbName = "people";
var conn = new SQLiteAsyncConnection (dbName);
conn.CreateTableAsync<Person> ().ContinueWith ((task) =>
{
foreach (var i in Enumerable.Range (0,1000)) {
var p = new Person ("Bob");
conn.InsertAsync (p).ContinueWith ((task2) =>
{
var id = p.Id;
this.InvokeOnMainThread (delegate {
this.recordCount.Text = id.ToString ();
this.recordCount.SetNeedsDisplay ();
}
);
}
);
}
}
);
}
async Task RunCreateTest()
{
var db = new SQLiteAsyncConnection(DatabasePath);
await db.CreateTableAsync<Person>();
await db.RunInTransactionAsync(async d =>
{
for (var i = 0; i < 10; i++)
await d.InsertAsync(new Person { FullName = "Person " + i.ToString() });
});
int count = 0;
await db.RunInTransactionAsync(async d =>
{
var table = db.Table<Person>();
count = await table.CountAsync();
});
var message = count == 10
? "Completed!"
: string.Format("Only inserted {0} rows!", count);
await dispatcher.RunIdleAsync(a => { CreateResult = message; });
}
private async Task CreateDatabaseAsync()
{
conn = new SQLiteAsyncConnection("Details.db3");
await conn.CreateTableAsync<Nutrition>();
}
public EmergencyRepository()
{
string DbFilePath = Path.Combine(
System.Environment.GetFolderPath(
System.Environment.SpecialFolder.LocalApplicationData), "NorthWind.db");
Database = new SQLiteAsyncConnection(DbFilePath);
Database.CreateTableAsync <Entities.Emergency>().Wait();
//h ttps://www.flaticon.com/icon-packs/firefighter?style_id=15
//h ttps://www.flaticon.com/packs/emergency-services-9
var emergency1 = new Data.Entities.Emergency
{
ID = 1,
Type = "Médico",
LogoSource = "ambulance.png",
Description = "Trauma por accidente vehicular",
Date = "2018/11/10",
Hour = "22:05",
Lat = "1",
Lng = "1"
};
var emergency2 = new Data.Entities.Emergency
{
ID = 2,
Type = "Incendio",
Description = "Incendio forestal",
LogoSource = "fire.png",
Date = "2018/08/10",
Hour = "22:05",
Lat = "2",
Lng = "2"
};
var emergency3 = new Data.Entities.Emergency
{
ID = 3,
Type = "Rescate",
Description = "Persona atrapada",
LogoSource = "ax.png",
Date = "2018/11/10",
Hour = "22:05",
Lat = "3",
Lng = "3"
};
var emergency4 = new Data.Entities.Emergency
{
ID = 4,
Type = "Administrativo",
Description = "Presencia en concierto",
LogoSource = "form.png",
Date = "2018/05/03",
Hour = "22:05",
Lat = "4",
Lng = "4"
};
var emergency5 = new Data.Entities.Emergency
{
ID = 5,
Type = "Sustancias",
Description = "Fuga de gas",
LogoSource = "Chemical.png",
Date = "2018/02/28",
Hour = "22:05",
Lat = "5",
Lng = "5"
};
var emergency6 = new Data.Entities.Emergency
{
ID = 6,
Type = "Incendio",
Description = "Incendio en Habitación",
LogoSource = "fire.png",
Date = "2018/11/10",
Hour = "22:05",
Lat = "2",
Lng = "2"
};
CreateEmergencyAsync(emergency1);
CreateEmergencyAsync(emergency2);
CreateEmergencyAsync(emergency3);
CreateEmergencyAsync(emergency4);
CreateEmergencyAsync(emergency5);
CreateEmergencyAsync(emergency6);
}
private void CreateTables()
{
connection.CreateTableAsync <RandomModel>();
connection.CreateTableAsync <Ingredient>();
connection.CreateTableAsync <Measure>();
}
public static async Task CreateData()
{
SQLiteAsyncConnection connection = new SQLiteAsyncConnection(DbName);
await connection.CreateTableAsync<DataBusLine>();
await connection.CreateTableAsync<DataPoint>();
System.Diagnostics.Debug.WriteLine("Create DB");
}
public DatabaseConnection(string dbPath)
{
conn = new SQLiteAsyncConnection(dbPath);
conn.CreateTableAsync<Posting>().Wait();
conn.CreateTableAsync<Search>().Wait();
conn.CreateTableAsync<RecentCity>().Wait();
conn.CreateTableAsync<FavoriteCategory>().Wait();
}
public DataStore()
{
Connection = new SQLiteAsyncConnection(Path.Combine(Root, location));
//create tables
Connection.CreateTableAsync<Trip>().Wait();
Connection.CreateTableAsync<Itinerary>().Wait();
Connection.CreateTableAsync<Event>().Wait();
}
