public PostgresStoreWithCompositePk()
{
var context = new PGCache(_connectionStringName);
// Build a table to play with from scratch each time:
if (context.TableExists("property"))
{
context.DropTable("property");
}
if (context.TableExists("building"))
{
context.DropTable("building");
}
var columnDefs = new List <string>();
columnDefs.Add("property_id integer NOT NULL");
columnDefs.Add("building_id integer NOT NULL");
columnDefs.Add("name Text NOT NULL");
columnDefs.Add("PRIMARY KEY (property_id, building_id)");
context.CreateTable("building", columnDefs);
var cache = new PGCache("chinookPG");
_propertyStore = new PGStore <Property>(cache);
_buildingStore = new PGStore <Building>(cache);
}
public PostgresDocStoreCompositePk()
{
var cache = new PGCache(_connectionStringName);
// Build a table to play with from scratch each time:
if (cache.TableExists("PropertyDocuments"))
{
cache.DropTable("PropertyDocuments");
}
if (cache.TableExists("BuildingDocuments"))
{
cache.DropTable("BuildingDocuments");
}
propertyDocs = new PGDocumentStore <PropertyDocument>(_connectionStringName);
buildingDocs = new PGDocumentStore <BuildingDocument>(_connectionStringName);
}
public BiggyListWithPGDocuments()
{
var _cache = new PGCache(_connectionStringName);
// This one will be re-created automagically:
if (_cache.TableExists("ClientDocuments"))
{
_cache.DropTable("ClientDocuments");
}
// This one will be re-created automagically:
if (_cache.TableExists("MonkeyDocuments"))
{
_cache.DropTable("MonkeyDocuments");
}
_clientDocuments = new BiggyList <ClientDocument>(new PGDocumentStore <ClientDocument>(_connectionStringName));
_monkeyDocuments = new BiggyList <MonkeyDocument>(new PGDocumentStore <MonkeyDocument>(_connectionStringName));
}
public PostgresDocumentStore()
{
_cache = new PGCache(_connectionStringName);
// Build a table to play with from scratch each time:
if (_cache.TableExists("ClientDocuments"))
{
_cache.DropTable("ClientDocuments");
}
if (_cache.TableExists("MonkeyDocuments"))
{
_cache.DropTable("MonkeyDocuments");
}
clientDocs = new PGDocumentStore <ClientDocument>(_connectionStringName);
monkeyDocs = new PGDocumentStore <MonkeyDocument>(_connectionStringName);
}
public PostgresDocumentStore()
{
var _cache = new PGCache(_connectionStringName);
// Build a table to play with from scratch each time:
// This needs a fix - gotta pass undelimited table name to one, and delimited to the other. FIX ME, DAMMIT!
if (_cache.TableExists("ClientDocuments"))
{
_cache.DropTable("\"ClientDocuments\"");
}
if (_cache.TableExists("MonkeyDocuments"))
{
_cache.DropTable("\"MonkeyDocuments\"");
}
clientDocs = new PGDocumentStore <ClientDocument>(_connectionStringName);
monkeyDocs = new PGDocumentStore <MonkeyDocument>(_connectionStringName);
}
public PostgresStore()
{
var context = new PGCache(_connectionStringName);
// Build a table to play with from scratch each time:
if (context.TableExists("client"))
{
context.DropTable("client");
}
var columnDefs = new List <string>();
columnDefs.Add("client_id serial PRIMARY KEY NOT NULL");
columnDefs.Add("last_name Text NOT NULL");
columnDefs.Add("first_name Text NOT NULL");
columnDefs.Add("email Text NOT NULL");
context.CreateTable("client", columnDefs);
}
public BiggyListWithPG()
{
var _cache = new PGCache(_connectionStringName);
// Build a table to play with from scratch each time:
if (_cache.TableExists("client"))
{
_cache.DropTable("client");
}
var columnDefs = new List <string>();
columnDefs.Add("client_id serial PRIMARY KEY NOT NULL");
columnDefs.Add("last_name Text NOT NULL");
columnDefs.Add("first_name Text NOT NULL");
columnDefs.Add("email Text NOT NULL");
_cache.CreateTable("client", columnDefs);
_clients = new BiggyList <Client>(new PGStore <Client>(_connectionStringName));
}
public static void Run()
{
var sw = new Stopwatch();
Console.WriteLine("===========================================================");
Console.WriteLine("Postgres - SOME FANCY QUERYING");
Console.WriteLine("===========================================================");
var _db = new PGCache(_connectionStringName);
IBiggy <Artist> _artists;
IBiggy <Album> _albums;
IBiggy <Track> _tracks;
Console.WriteLine("Loading up Artists from Chinook...");
sw.Start();
_artists = new BiggyList <Artist>(new PGStore <Artist>(_db));
sw.Stop();
Console.WriteLine("\tLoaded {0} Artist records in {1} ms", _artists.Count(), sw.ElapsedMilliseconds);
Console.WriteLine("Loading up Albums from Chinook...");
sw.Reset();
sw.Start();
_albums = new BiggyList <Album>(new PGStore <Album>(_db));
sw.Stop();
Console.WriteLine("\tLoaded {0} Albums in {1} ms", _artists.Count(), sw.ElapsedMilliseconds);
Console.WriteLine("Loading up tracks from Chinook...");
sw.Reset();
sw.Start();
_tracks = new BiggyList <Track>(new PGStore <Track>(_db));
sw.Stop();
Console.WriteLine("\tLoaded {0} Tracks in {1} ms", _tracks.Count(), sw.ElapsedMilliseconds);
Console.WriteLine("Grab the record for AC/DC...");
sw.Reset();
sw.Start();
var acdc = _artists.FirstOrDefault(a => a.Name == "AC/DC");
sw.Stop();
Console.WriteLine("\tFound AC/DC from memory in {0} ms", sw.ElapsedMilliseconds);
Console.WriteLine("Find all the albums by AC/DC ...");
sw.Reset();
sw.Start();
var acdcAlbums = _albums.Where(a => a.ArtistId == acdc.ArtistId);
sw.Stop();
Console.WriteLine("\tFound All {0} AC/DC albums from memory in {1} ms", acdcAlbums.Count(), sw.ElapsedMilliseconds);
Console.WriteLine("Find all the Tracks from Albums by AC/DC ...");
sw.Reset();
sw.Start();
var acdcTracks = from t in _tracks
join a in acdcAlbums on t.AlbumId equals a.AlbumId
select t;
sw.Stop();
Console.WriteLine("\tFound All {0} tracks by ACDC using in-memory JOIN in {1} ms:", acdcTracks.Count(), sw.ElapsedMilliseconds);
foreach (var track in acdcTracks)
{
Console.WriteLine("\t-{0}", track.Name);
}
Console.WriteLine(Environment.NewLine);
Console.WriteLine("===========================================================");
Console.WriteLine("POSTGES - BASIC CRUD OPERATIONS");
Console.WriteLine("===========================================================");
IBiggy <Customer> _customers;
sw.Reset();
Console.WriteLine("Loading up customers from Chinook...");
sw.Start();
_customers = new BiggyList <Customer>(new PGStore <Customer>(_db));
sw.Stop();
Console.WriteLine("\tLoaded {0} records in {1}ms", _customers.Count(), sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("INSERTING a NEW Customer into Chinook...");
var newCustomer = new Customer()
{
LastName = "Atten", FirstName = "John", Email = "*****@*****.**"
};
sw.Start();
_customers.Add(newCustomer);
sw.Stop();
Console.WriteLine("\tWrote 1 record for a new count of {0} records in {1} ms", _customers.Count(), sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("UPDATING the new Customer record in Chinook...");
newCustomer.FirstName = "Fred";
sw.Start();
_customers.Update(newCustomer);
sw.Stop();
Console.WriteLine("\tUpdated 1 record for a new count of {0} records in {1} ms", _customers.Count(), sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("DELETE the new Customer record in Chinook...");
sw.Start();
_customers.Remove(newCustomer);
sw.Stop();
Console.WriteLine("\tDeleted 1 record for a new count of {0} records in {1} ms", _customers.Count(), sw.ElapsedMilliseconds);
Console.WriteLine(Environment.NewLine);
Console.WriteLine("===========================================================");
Console.WriteLine("POSTGES - BULK INSERTS AND DELETIONS");
Console.WriteLine("===========================================================");
Console.WriteLine("Creating Test Table...");
if (_db.TableExists("client"))
{
_db.DropTable("client");
}
var columnDefs = new List <string>();
columnDefs.Add("client_id serial PRIMARY KEY NOT NULL");
columnDefs.Add("last_name Text NOT NULL");
columnDefs.Add("first_name Text NOT NULL");
columnDefs.Add("email Text NOT NULL");
_db.CreateTable("client", columnDefs);
IBiggy <Client> _clients;
sw.Reset();
int INSERT_QTY = 10000;
Console.WriteLine("BULK INSERTING {0} client records in Chinook...", INSERT_QTY);
_clients = new BiggyList <Client>(new PGStore <Client>(_db));
var inserts = new List <Client>();
for (int i = 0; i < INSERT_QTY; i++)
{
inserts.Add(new Client()
{
LastName = string.Format("Atten {0}", i.ToString()), FirstName = "John", Email = "*****@*****.**"
});
}
sw.Start();
var inserted = _clients.Add(inserts);
sw.Stop();
Console.WriteLine("\tInserted {0} records in {1} ms", inserted.Count(), sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("Loading up Bulk inserted CLients from Chinook...");
sw.Start();
_clients = new BiggyList <Client>(new PGStore <Client>(_db));
sw.Stop();
Console.WriteLine("\tLoaded {0} records in {1}ms", _clients.Count(), sw.ElapsedMilliseconds);
sw.Reset();
Console.WriteLine("DELETING added records from Chinook...");
var toRemove = _clients.Where(x => x.Email == "*****@*****.**");
sw.Start();
var removed = _clients.Remove(toRemove.ToList());
sw.Stop();
Console.WriteLine("\tDeleted {0} records in {1}ms", removed.Count(), sw.ElapsedMilliseconds);
}
public static void Run()
{
var sw = new Stopwatch();
var _myDatabase = new PGCache("chinookPG");
Console.WriteLine("===========================================================");
Console.WriteLine("POSTGRES DOCUMENTS - INSERT A BUNCH OF DOCUMENTS");
Console.WriteLine("===========================================================");
// Build a table to play with from scratch each time:
if (_myDatabase.TableExists("ClientDocuments"))
{
_myDatabase.DropTable("\"ClientDocuments\"");
}
IBiggyStore <ClientDocument> clientDocStore = new PGDocumentStore <ClientDocument>(_myDatabase);
IBiggy <ClientDocument> clientDocs = new BiggyList <ClientDocument>(clientDocStore);
int INSERT_MODEST_QTY = 10000;
Console.WriteLine("Insert {0} records as documents...", INSERT_MODEST_QTY);
var addThese = new List <ClientDocument>();
for (int i = 0; i < INSERT_MODEST_QTY; i++)
{
addThese.Add(new ClientDocument {
LastName = "Atten",
FirstName = "John",
Email = "*****@*****.**"
});
}
sw.Start();
clientDocs.Add(addThese);
sw.Stop();
Console.WriteLine("Inserted {0} records as documents in {1} ms", INSERT_MODEST_QTY, sw.ElapsedMilliseconds);
Console.WriteLine("===========================================================");
Console.WriteLine("POSTGRES DOCUMENTS - SOME FANCY COMPLEX DOCUMENT STUFF");
Console.WriteLine("===========================================================");
// Start clean with no existing table:
if (_myDatabase.TableExists("ArtistWithAlbums"))
{
_myDatabase.DropTable("\"ArtistWithAlbums\"");
}
Console.WriteLine("Retreive artists, albums, and tracks from Db...");
sw.Reset();
sw.Start();
IBiggyStore <Artist> _artistStore = new PGStore <Artist>(_myDatabase);
IBiggyStore <Album> _albumStore = new PGStore <Album>(_myDatabase);
IBiggyStore <Track> _trackStore = new PGStore <Track>(_myDatabase);
IBiggy <Artist> _artists = new BiggyList <Artist>(_artistStore);
IBiggy <Album> _albums = new BiggyList <Album>(_albumStore);
IBiggy <Track> _tracks = new BiggyList <Track>(_trackStore);
sw.Stop();
Console.WriteLine("Query each artists albums and write to complex document store...");
var list = new List <ArtistWithAlbums>();
foreach (var artist in _artists)
{
var artistAlbums = from a in _albums
where a.ArtistId == artist.ArtistId
select a;
var newArtistWithAlbums = new ArtistWithAlbums()
{
ArtistId = artist.ArtistId,
Name = artist.Name,
Albums = artistAlbums.ToList()
};
list.Add(newArtistWithAlbums);
}
var docStore = new PGDocumentStore <ArtistWithAlbums>(_myDatabase);
var artistWithAlbumsDocuments = new BiggyList <ArtistWithAlbums>(docStore);
artistWithAlbumsDocuments.Add(list);
sw.Stop();
Console.WriteLine("Added {0} Artist + Album records as complex documents in {1} ms", _artists.Count(), sw.ElapsedMilliseconds);
Console.WriteLine("Retreive artists and albums from Complex document store and hydrate");
sw.Reset();
sw.Start();
artistWithAlbumsDocuments = new BiggyList <ArtistWithAlbums>(docStore);
sw.Stop();
int artistCount = artistWithAlbumsDocuments.Count();
int albumsCount = 0;
foreach (var artist in artistWithAlbumsDocuments)
{
albumsCount += artist.Albums.Count();
}
Console.WriteLine("\tRetreived and Re-Hydrated {0} Artist + {1} Album records from complex documents in {2} ms",
artistCount, albumsCount, sw.ElapsedMilliseconds);
}