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);
        }
Beispiel #6
0
        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);
        }
Beispiel #7
0
        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));
        }
Beispiel #8
0
        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);
        }
Beispiel #9
0
        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);
        }