fybdatabase.h

#pragma once 


namespace trader {

    namespace FybDatabase {
    
        class Ticker_Detailed :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Current Unix Timestamp
                Poco::Int32 timeStamp;
                
                bool isSetTimeStamp() {
                    return (timeStamp != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Snapshot of Ask Price
                double  ask;
                
                bool isSetAsk() {
                    return (ask != std::numeric_limits<double>::max());
                }
                
                // Snapshot of Bid Price
                double  bid;
                
                bool isSetBid() {
                    return (bid != std::numeric_limits<double>::max());
                }
                
                // Snapshot of Last Price
                double  last;
                
                bool isSetLast() {
                    return (last != std::numeric_limits<double>::max());
                }
                
                // Trading Volume
                double  vol;
                
                bool isSetVol() {
                    return (vol != std::numeric_limits<double>::max());
                }
                
                Record()
                : timeStamp(std::numeric_limits<Poco::Int32>::max())
                , ask(std::numeric_limits<double>::max())
                , bid(std::numeric_limits<double>::max())
                , last(std::numeric_limits<double>::max())
                , vol(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Current Unix Timestamp
                Poco::Int32 timeStamp;
                
                bool isSetTimeStamp() {
                    return (timeStamp != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Snapshot of Ask Price
                double  ask;
                
                bool isSetAsk() {
                    return (ask != std::numeric_limits<double>::max());
                }
                
                // Snapshot of Bid Price
                double  bid;
                
                bool isSetBid() {
                    return (bid != std::numeric_limits<double>::max());
                }
                
                // Snapshot of Last Price
                double  last;
                
                bool isSetLast() {
                    return (last != std::numeric_limits<double>::max());
                }
                
                // Trading Volume
                double  vol;
                
                bool isSetVol() {
                    return (vol != std::numeric_limits<double>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : timeStamp(std::numeric_limits<Poco::Int32>::max())
                , ask(std::numeric_limits<double>::max())
                , bid(std::numeric_limits<double>::max())
                , last(std::numeric_limits<double>::max())
                , vol(std::numeric_limits<double>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            Ticker_Detailed(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~Ticker_Detailed();
            
            void init();
            
            void clear();
            
            void insert(Ticker_Detailed::Record& record);
            
            void insertOnce(Ticker_Detailed::Record& record);
            
            void insertMultiple(std::vector<Ticker_Detailed::Record>& records);
            
            void insertMultiple(std::vector<Ticker_Detailed::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<Ticker_Detailed::Record>& records);
            
            void deleteMultiple(std::vector<Ticker_Detailed::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(Ticker_Detailed::Record& record);
            
            void insertUnique(Ticker_Detailed::Record& record);
            
            void getLatest(Ticker_Detailed::RecordWithId& rec);
            
            std::size_t getAll(std::vector<Ticker_Detailed::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //Ticker_Detailed
        
        class Account_Balance :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Current Unix Timestamp
                Poco::Int32 timeStamp;
                
                bool isSetTimeStamp() {
                    return (timeStamp != std::numeric_limits<Poco::Int32>::max());
                }
                
                // BTC remaining in Account
                double  btcBal;
                
                bool isSetBtcBal() {
                    return (btcBal != std::numeric_limits<double>::max());
                }
                
                // SGD available in Account
                double  sgdBal;
                
                bool isSetSgdBal() {
                    return (sgdBal != std::numeric_limits<double>::max());
                }
                
                Record()
                : timeStamp(std::numeric_limits<Poco::Int32>::max())
                , btcBal(std::numeric_limits<double>::max())
                , sgdBal(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Current Unix Timestamp
                Poco::Int32 timeStamp;
                
                bool isSetTimeStamp() {
                    return (timeStamp != std::numeric_limits<Poco::Int32>::max());
                }
                
                // BTC remaining in Account
                double  btcBal;
                
                bool isSetBtcBal() {
                    return (btcBal != std::numeric_limits<double>::max());
                }
                
                // SGD available in Account
                double  sgdBal;
                
                bool isSetSgdBal() {
                    return (sgdBal != std::numeric_limits<double>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : timeStamp(std::numeric_limits<Poco::Int32>::max())
                , btcBal(std::numeric_limits<double>::max())
                , sgdBal(std::numeric_limits<double>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            Account_Balance(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~Account_Balance();
            
            void init();
            
            void clear();
            
            void insert(Account_Balance::Record& record);
            
            void insertOnce(Account_Balance::Record& record);
            
            void insertMultiple(std::vector<Account_Balance::Record>& records);
            
            void insertMultiple(std::vector<Account_Balance::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<Account_Balance::Record>& records);
            
            void deleteMultiple(std::vector<Account_Balance::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(Account_Balance::Record& record);
            
            void insertUnique(Account_Balance::Record& record);
            
            void getLatest(Account_Balance::RecordWithId& rec);
            
            std::size_t getAll(std::vector<Account_Balance::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //Account_Balance
        
        class Account_Info :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // FYB Account Number for SGD Deposits
                std::string accNum;
                
                bool isSetAccNum() {
                    return (accNum != "Empty");
                }
                
                // BTC Address to Deposit Funds
                std::string btcAddress;
                
                bool isSetBtcAddress() {
                    return (btcAddress != "Empty");
                }
                
                // Registered Email Address
                std::string email;
                
                bool isSetEmail() {
                    return (email != "Empty");
                }
                
                Record()
                : accNum("Empty")
                , btcAddress("Empty")
                , email("Empty")
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // FYB Account Number for SGD Deposits
                std::string accNum;
                
                bool isSetAccNum() {
                    return (accNum != "Empty");
                }
                
                // BTC Address to Deposit Funds
                std::string btcAddress;
                
                bool isSetBtcAddress() {
                    return (btcAddress != "Empty");
                }
                
                // Registered Email Address
                std::string email;
                
                bool isSetEmail() {
                    return (email != "Empty");
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : accNum("Empty")
                , btcAddress("Empty")
                , email("Empty")
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            Account_Info(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~Account_Info();
            
            void init();
            
            void clear();
            
            void insert(Account_Info::Record& record);
            
            void insertOnce(Account_Info::Record& record);
            
            void insertMultiple(std::vector<Account_Info::Record>& records);
            
            void insertMultiple(std::vector<Account_Info::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<Account_Info::Record>& records);
            
            void deleteMultiple(std::vector<Account_Info::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(Account_Info::Record& record);
            
            void insertUnique(Account_Info::Record& record);
            
            void getLatest(Account_Info::RecordWithId& rec);
            
            std::size_t getAll(std::vector<Account_Info::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //Account_Info
        
        class Trade_History :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Id for each trade
                Poco::Int32 tid;
                
                bool isSetTid() {
                    return (tid != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount traded in this transaction
                double  amt;
                
                bool isSetAmt() {
                    return (amt != std::numeric_limits<double>::max());
                }
                
                // Price at which trade was made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Date and Time when trade occured
                Poco::Int32 date;
                
                bool isSetDate() {
                    return (date != std::numeric_limits<Poco::Int32>::max());
                }
                
                Record()
                : tid(std::numeric_limits<Poco::Int32>::max())
                , amt(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , date(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Id for each trade
                Poco::Int32 tid;
                
                bool isSetTid() {
                    return (tid != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount traded in this transaction
                double  amt;
                
                bool isSetAmt() {
                    return (amt != std::numeric_limits<double>::max());
                }
                
                // Price at which trade was made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Date and Time when trade occured
                Poco::Int32 date;
                
                bool isSetDate() {
                    return (date != std::numeric_limits<Poco::Int32>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : tid(std::numeric_limits<Poco::Int32>::max())
                , amt(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , date(std::numeric_limits<Poco::Int32>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            Trade_History(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~Trade_History();
            
            void init();
            
            void clear();
            
            void insert(Trade_History::Record& record);
            
            void insertOnce(Trade_History::Record& record);
            
            void insertMultiple(std::vector<Trade_History::Record>& records);
            
            void insertMultiple(std::vector<Trade_History::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<Trade_History::Record>& records);
            
            void deleteMultiple(std::vector<Trade_History::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(Trade_History::Record& record);
            
            void insertUnique(Trade_History::Record& record);
            
            void getLatest(Trade_History::RecordWithId& rec);
            
            std::size_t getAll(std::vector<Trade_History::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //Trade_History
        
        class Order_Book_Asks :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Current Unix Timestamp
                Poco::Int32 dateCreated;
                
                bool isSetDateCreated() {
                    return (dateCreated != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Current Unix Timestamp
                Poco::Int32 dateRemoved;
                
                bool isSetDateRemoved() {
                    return (dateRemoved != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Price offered
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Volume at that price
                double  volume;
                
                bool isSetVolume() {
                    return (volume != std::numeric_limits<double>::max());
                }
                
                Record()
                : dateCreated(std::numeric_limits<Poco::Int32>::max())
                , dateRemoved(std::numeric_limits<Poco::Int32>::max())
                , price(std::numeric_limits<double>::max())
                , volume(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Current Unix Timestamp
                Poco::Int32 dateCreated;
                
                bool isSetDateCreated() {
                    return (dateCreated != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Current Unix Timestamp
                Poco::Int32 dateRemoved;
                
                bool isSetDateRemoved() {
                    return (dateRemoved != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Price offered
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Volume at that price
                double  volume;
                
                bool isSetVolume() {
                    return (volume != std::numeric_limits<double>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : dateCreated(std::numeric_limits<Poco::Int32>::max())
                , dateRemoved(std::numeric_limits<Poco::Int32>::max())
                , price(std::numeric_limits<double>::max())
                , volume(std::numeric_limits<double>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            Order_Book_Asks(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~Order_Book_Asks();
            
            void init();
            
            void clear();
            
            void insert(Order_Book_Asks::Record& record);
            
            void insertOnce(Order_Book_Asks::Record& record);
            
            void insertMultiple(std::vector<Order_Book_Asks::Record>& records);
            
            void insertMultiple(std::vector<Order_Book_Asks::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<Order_Book_Asks::Record>& records);
            
            void deleteMultiple(std::vector<Order_Book_Asks::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(Order_Book_Asks::Record& record);
            
            void insertUnique(Order_Book_Asks::Record& record);
            
            void getLatest(Order_Book_Asks::RecordWithId& rec);
            
            std::size_t getAll(std::vector<Order_Book_Asks::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //Order_Book_Asks
        
        class Order_Book_Bids :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Current Unix Timestamp
                Poco::Int32 dateCreated;
                
                bool isSetDateCreated() {
                    return (dateCreated != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Current Unix Timestamp
                Poco::Int32 dateRemoved;
                
                bool isSetDateRemoved() {
                    return (dateRemoved != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Price offered
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Volume at that price
                double  volume;
                
                bool isSetVolume() {
                    return (volume != std::numeric_limits<double>::max());
                }
                
                Record()
                : dateCreated(std::numeric_limits<Poco::Int32>::max())
                , dateRemoved(std::numeric_limits<Poco::Int32>::max())
                , price(std::numeric_limits<double>::max())
                , volume(std::numeric_limits<double>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Current Unix Timestamp
                Poco::Int32 dateCreated;
                
                bool isSetDateCreated() {
                    return (dateCreated != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Current Unix Timestamp
                Poco::Int32 dateRemoved;
                
                bool isSetDateRemoved() {
                    return (dateRemoved != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Price offered
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Volume at that price
                double  volume;
                
                bool isSetVolume() {
                    return (volume != std::numeric_limits<double>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : dateCreated(std::numeric_limits<Poco::Int32>::max())
                , dateRemoved(std::numeric_limits<Poco::Int32>::max())
                , price(std::numeric_limits<double>::max())
                , volume(std::numeric_limits<double>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            Order_Book_Bids(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~Order_Book_Bids();
            
            void init();
            
            void clear();
            
            void insert(Order_Book_Bids::Record& record);
            
            void insertOnce(Order_Book_Bids::Record& record);
            
            void insertMultiple(std::vector<Order_Book_Bids::Record>& records);
            
            void insertMultiple(std::vector<Order_Book_Bids::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<Order_Book_Bids::Record>& records);
            
            void deleteMultiple(std::vector<Order_Book_Bids::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(Order_Book_Bids::Record& record);
            
            void insertUnique(Order_Book_Bids::Record& record);
            
            void getLatest(Order_Book_Bids::RecordWithId& rec);
            
            std::size_t getAll(std::vector<Order_Book_Bids::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //Order_Book_Bids
        
        class My_Pending_Sell_Orders :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Unique ticket id for each pending sell order
                Poco::Int32 ticket;
                
                bool isSetTicket() {
                    return (ticket != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount traded in this transaction
                double  amt;
                
                bool isSetAmt() {
                    return (amt != std::numeric_limits<double>::max());
                }
                
                // Price at which trade was made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Date and Time order was created
                Poco::Int32 date;
                
                bool isSetDate() {
                    return (date != std::numeric_limits<Poco::Int32>::max());
                }
                
                Record()
                : ticket(std::numeric_limits<Poco::Int32>::max())
                , amt(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , date(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Unique ticket id for each pending sell order
                Poco::Int32 ticket;
                
                bool isSetTicket() {
                    return (ticket != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount traded in this transaction
                double  amt;
                
                bool isSetAmt() {
                    return (amt != std::numeric_limits<double>::max());
                }
                
                // Price at which trade was made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Date and Time order was created
                Poco::Int32 date;
                
                bool isSetDate() {
                    return (date != std::numeric_limits<Poco::Int32>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : ticket(std::numeric_limits<Poco::Int32>::max())
                , amt(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , date(std::numeric_limits<Poco::Int32>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            My_Pending_Sell_Orders(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~My_Pending_Sell_Orders();
            
            void init();
            
            void clear();
            
            void insert(My_Pending_Sell_Orders::Record& record);
            
            void insertOnce(My_Pending_Sell_Orders::Record& record);
            
            void insertMultiple(std::vector<My_Pending_Sell_Orders::Record>& records);
            
            void insertMultiple(std::vector<My_Pending_Sell_Orders::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<My_Pending_Sell_Orders::Record>& records);
            
            void deleteMultiple(std::vector<My_Pending_Sell_Orders::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(My_Pending_Sell_Orders::Record& record);
            
            void insertUnique(My_Pending_Sell_Orders::Record& record);
            
            void getLatest(My_Pending_Sell_Orders::RecordWithId& rec);
            
            std::size_t getAll(std::vector<My_Pending_Sell_Orders::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //My_Pending_Sell_Orders
        
        class My_Pending_Buy_Orders :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Unique ticket id for each pending buy order
                Poco::Int32 ticket;
                
                bool isSetTicket() {
                    return (ticket != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount to trade in this transaction
                double  amt;
                
                bool isSetAmt() {
                    return (amt != std::numeric_limits<double>::max());
                }
                
                // Price at which trade should be made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Date and Time order was created
                Poco::Int32 date;
                
                bool isSetDate() {
                    return (date != std::numeric_limits<Poco::Int32>::max());
                }
                
                Record()
                : ticket(std::numeric_limits<Poco::Int32>::max())
                , amt(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , date(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Unique ticket id for each pending buy order
                Poco::Int32 ticket;
                
                bool isSetTicket() {
                    return (ticket != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount to trade in this transaction
                double  amt;
                
                bool isSetAmt() {
                    return (amt != std::numeric_limits<double>::max());
                }
                
                // Price at which trade should be made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Date and Time order was created
                Poco::Int32 date;
                
                bool isSetDate() {
                    return (date != std::numeric_limits<Poco::Int32>::max());
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : ticket(std::numeric_limits<Poco::Int32>::max())
                , amt(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , date(std::numeric_limits<Poco::Int32>::max())
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            My_Pending_Buy_Orders(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~My_Pending_Buy_Orders();
            
            void init();
            
            void clear();
            
            void insert(My_Pending_Buy_Orders::Record& record);
            
            void insertOnce(My_Pending_Buy_Orders::Record& record);
            
            void insertMultiple(std::vector<My_Pending_Buy_Orders::Record>& records);
            
            void insertMultiple(std::vector<My_Pending_Buy_Orders::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<My_Pending_Buy_Orders::Record>& records);
            
            void deleteMultiple(std::vector<My_Pending_Buy_Orders::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(My_Pending_Buy_Orders::Record& record);
            
            void insertUnique(My_Pending_Buy_Orders::Record& record);
            
            void getLatest(My_Pending_Buy_Orders::RecordWithId& rec);
            
            std::size_t getAll(std::vector<My_Pending_Buy_Orders::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //My_Pending_Buy_Orders
        
        class My_Trade_History :  public Poco::RefCountedObject {
        public:
            
            struct Record {
                
                // Unique ticket id for each trade
                Poco::Int32 ticket;
                
                bool isSetTicket() {
                    return (ticket != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Date and Time order was created
                Poco::Int32 dateCreated;
                
                bool isSetDateCreated() {
                    return (dateCreated != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Date and Time order was executed
                Poco::Int32 dateExecuted;
                
                bool isSetDateExecuted() {
                    return (dateExecuted != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount to trade in this transaction
                double  qty;
                
                bool isSetQty() {
                    return (qty != std::numeric_limits<double>::max());
                }
                
                // Price at which trade should be made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Price at which trade should be made
                std::string status;
                
                bool isSetStatus() {
                    return (status != "Empty");
                }
                
                // Price at which trade should be made
                std::string type;
                
                bool isSetType() {
                    return (type != "Empty");
                }
                
                Record()
                : ticket(std::numeric_limits<Poco::Int32>::max())
                , dateCreated(std::numeric_limits<Poco::Int32>::max())
                , dateExecuted(std::numeric_limits<Poco::Int32>::max())
                , qty(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , status("Empty")
                , type("Empty")
                {
                }
            
            };
            
            
            struct RecordWithId {
                
                // Unique ticket id for each trade
                Poco::Int32 ticket;
                
                bool isSetTicket() {
                    return (ticket != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Date and Time order was created
                Poco::Int32 dateCreated;
                
                bool isSetDateCreated() {
                    return (dateCreated != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Date and Time order was executed
                Poco::Int32 dateExecuted;
                
                bool isSetDateExecuted() {
                    return (dateExecuted != std::numeric_limits<Poco::Int32>::max());
                }
                
                // Amount to trade in this transaction
                double  qty;
                
                bool isSetQty() {
                    return (qty != std::numeric_limits<double>::max());
                }
                
                // Price at which trade should be made
                double  price;
                
                bool isSetPrice() {
                    return (price != std::numeric_limits<double>::max());
                }
                
                // Price at which trade should be made
                std::string status;
                
                bool isSetStatus() {
                    return (status != "Empty");
                }
                
                // Price at which trade should be made
                std::string type;
                
                bool isSetType() {
                    return (type != "Empty");
                }
                
                //Record ID in database
                Poco::Int32 id;
                
                RecordWithId()
                : ticket(std::numeric_limits<Poco::Int32>::max())
                , dateCreated(std::numeric_limits<Poco::Int32>::max())
                , dateExecuted(std::numeric_limits<Poco::Int32>::max())
                , qty(std::numeric_limits<double>::max())
                , price(std::numeric_limits<double>::max())
                , status("Empty")
                , type("Empty")
                , id(std::numeric_limits<Poco::Int32>::max())
                {
                }
            
            };
            
            
            My_Trade_History(Poco::Data::Session* _db, std::string _suffix = "");
            
            ~My_Trade_History();
            
            void init();
            
            void clear();
            
            void insert(My_Trade_History::Record& record);
            
            void insertOnce(My_Trade_History::Record& record);
            
            void insertMultiple(std::vector<My_Trade_History::Record>& records);
            
            void insertMultiple(std::vector<My_Trade_History::RecordWithId>& records);
            
            void insertMultipleUnique(std::vector<My_Trade_History::Record>& records);
            
            void deleteMultiple(std::vector<My_Trade_History::RecordWithId>& records);
            
            void insertAndDeleteUnchanged(My_Trade_History::Record& record);
            
            void insertUnique(My_Trade_History::Record& record);
            
            void getLatest(My_Trade_History::RecordWithId& rec);
            
            std::size_t getAll(std::vector<My_Trade_History::RecordWithId>& records, std::string condition);
            
            Poco::Data::Session* db;
            
            std::string tableName;
            
        }; //My_Trade_History
        
        class Tables :  public Poco::RefCountedObject {
        public:
            
            Tables(Poco::Data::Session* _db);
            
            ~Tables();
            
            void init();
            
            void clear();
            
            Poco::Data::Session* db;
            
            Poco::AutoPtr<Ticker_Detailed> ticker_DetailedTable;
            
            Poco::AutoPtr<Account_Balance> account_BalanceTable;
            
            Poco::AutoPtr<Account_Info> account_InfoTable;
            
            Poco::AutoPtr<Trade_History> trade_HistoryTable;
            
            Poco::AutoPtr<Order_Book_Asks> order_Book_AsksTable;
            
            Poco::AutoPtr<Order_Book_Bids> order_Book_BidsTable;
            
            Poco::AutoPtr<My_Pending_Sell_Orders> my_Pending_Sell_OrdersTable;
            
            Poco::AutoPtr<My_Pending_Buy_Orders> my_Pending_Buy_OrdersTable;
            
            Poco::AutoPtr<My_Trade_History> my_Trade_HistoryTable;
            
        }; //Tables
        
    } //FybDatabase
} //trader

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Ticker_Detailed::Record>
{
    public:
    static std::size_t size()
    {
        return 5;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Ticker_Detailed::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.timeStamp , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.ask , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.bid , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.last , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.vol , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Ticker_Detailed::Record& record, trader::FybDatabase::Ticker_Detailed::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.timeStamp, deflt.timeStamp, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.ask, deflt.ask, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.bid, deflt.bid, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.last, deflt.last, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.vol, deflt.vol, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Ticker_Detailed::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.timeStamp, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.ask, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.bid, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.last, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.vol, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Ticker_Detailed::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 6;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Ticker_Detailed::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.timeStamp , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.ask , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.bid , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.last , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.vol , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Ticker_Detailed::RecordWithId& record, trader::FybDatabase::Ticker_Detailed::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.timeStamp, deflt.timeStamp, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.ask, deflt.ask, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.bid, deflt.bid, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.last, deflt.last, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.vol, deflt.vol, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Ticker_Detailed::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.timeStamp, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.ask, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.bid, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.last, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.vol, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Account_Balance::Record>
{
    public:
    static std::size_t size()
    {
        return 3;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Account_Balance::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.timeStamp , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.btcBal , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.sgdBal , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Account_Balance::Record& record, trader::FybDatabase::Account_Balance::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.timeStamp, deflt.timeStamp, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.btcBal, deflt.btcBal, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.sgdBal, deflt.sgdBal, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Account_Balance::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.timeStamp, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.btcBal, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.sgdBal, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Account_Balance::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Account_Balance::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.timeStamp , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.btcBal , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.sgdBal , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Account_Balance::RecordWithId& record, trader::FybDatabase::Account_Balance::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.timeStamp, deflt.timeStamp, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.btcBal, deflt.btcBal, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.sgdBal, deflt.sgdBal, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Account_Balance::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.timeStamp, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.btcBal, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.sgdBal, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Account_Info::Record>
{
    public:
    static std::size_t size()
    {
        return 3;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Account_Info::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.accNum , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.btcAddress , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.email , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Account_Info::Record& record, trader::FybDatabase::Account_Info::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.accNum, deflt.accNum, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.btcAddress, deflt.btcAddress, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.email, deflt.email, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Account_Info::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.accNum, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.btcAddress, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.email, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Account_Info::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Account_Info::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.accNum , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.btcAddress , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.email , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Account_Info::RecordWithId& record, trader::FybDatabase::Account_Info::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.accNum, deflt.accNum, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.btcAddress, deflt.btcAddress, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.email, deflt.email, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Account_Info::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.accNum, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.btcAddress, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.email, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Trade_History::Record>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Trade_History::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.tid , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.amt , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.date , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Trade_History::Record& record, trader::FybDatabase::Trade_History::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.tid, deflt.tid, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.amt, deflt.amt, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.date, deflt.date, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Trade_History::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.tid, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.amt, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.date, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Trade_History::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 5;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Trade_History::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.tid , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.amt , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.date , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Trade_History::RecordWithId& record, trader::FybDatabase::Trade_History::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.tid, deflt.tid, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.amt, deflt.amt, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.date, deflt.date, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Trade_History::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.tid, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.amt, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.date, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Order_Book_Asks::Record>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Order_Book_Asks::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateCreated , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateRemoved , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.volume , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Order_Book_Asks::Record& record, trader::FybDatabase::Order_Book_Asks::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateCreated, deflt.dateCreated, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateRemoved, deflt.dateRemoved, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.volume, deflt.volume, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Order_Book_Asks::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateCreated, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateRemoved, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.volume, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Order_Book_Asks::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 5;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Order_Book_Asks::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateCreated , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateRemoved , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.volume , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Order_Book_Asks::RecordWithId& record, trader::FybDatabase::Order_Book_Asks::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateCreated, deflt.dateCreated, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateRemoved, deflt.dateRemoved, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.volume, deflt.volume, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Order_Book_Asks::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateCreated, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateRemoved, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.volume, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Order_Book_Bids::Record>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Order_Book_Bids::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateCreated , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateRemoved , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.volume , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Order_Book_Bids::Record& record, trader::FybDatabase::Order_Book_Bids::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateCreated, deflt.dateCreated, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateRemoved, deflt.dateRemoved, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.volume, deflt.volume, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Order_Book_Bids::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateCreated, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateRemoved, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.volume, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::Order_Book_Bids::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 5;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::Order_Book_Bids::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateCreated , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateRemoved , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.volume , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::Order_Book_Bids::RecordWithId& record, trader::FybDatabase::Order_Book_Bids::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateCreated, deflt.dateCreated, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateRemoved, deflt.dateRemoved, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.volume, deflt.volume, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::Order_Book_Bids::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateCreated, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateRemoved, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.volume, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::My_Pending_Sell_Orders::Record>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::My_Pending_Sell_Orders::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.ticket , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.amt , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.date , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::My_Pending_Sell_Orders::Record& record, trader::FybDatabase::My_Pending_Sell_Orders::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.ticket, deflt.ticket, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.amt, deflt.amt, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.date, deflt.date, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::My_Pending_Sell_Orders::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.ticket, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.amt, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.date, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::My_Pending_Sell_Orders::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 5;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::My_Pending_Sell_Orders::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.ticket , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.amt , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.date , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::My_Pending_Sell_Orders::RecordWithId& record, trader::FybDatabase::My_Pending_Sell_Orders::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.ticket, deflt.ticket, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.amt, deflt.amt, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.date, deflt.date, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::My_Pending_Sell_Orders::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.ticket, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.amt, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.date, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::My_Pending_Buy_Orders::Record>
{
    public:
    static std::size_t size()
    {
        return 4;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::My_Pending_Buy_Orders::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.ticket , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.amt , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.date , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::My_Pending_Buy_Orders::Record& record, trader::FybDatabase::My_Pending_Buy_Orders::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.ticket, deflt.ticket, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.amt, deflt.amt, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.date, deflt.date, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::My_Pending_Buy_Orders::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.ticket, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.amt, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.date, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::My_Pending_Buy_Orders::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 5;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::My_Pending_Buy_Orders::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.ticket , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.amt , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.date , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::My_Pending_Buy_Orders::RecordWithId& record, trader::FybDatabase::My_Pending_Buy_Orders::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.ticket, deflt.ticket, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.amt, deflt.amt, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.date, deflt.date, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::My_Pending_Buy_Orders::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.ticket, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.amt, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.date, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::My_Trade_History::Record>
{
    public:
    static std::size_t size()
    {
        return 7;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::My_Trade_History::Record& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.ticket , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateCreated , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateExecuted , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.qty , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.status , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.type , pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::My_Trade_History::Record& record, trader::FybDatabase::My_Trade_History::Record& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.ticket, deflt.ticket, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateCreated, deflt.dateCreated, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateExecuted, deflt.dateExecuted, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.qty, deflt.qty, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.status, deflt.status, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.type, deflt.type, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::My_Trade_History::Record& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.ticket, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateCreated, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateExecuted, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.qty, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.status, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.type, pPrep);
    }
}
;

template <>
class Poco::Data::TypeHandler<trader::FybDatabase::My_Trade_History::RecordWithId>
{
    public:
    static std::size_t size()
    {
        return 8;
    }
    
    static void bind(std::size_t pos, const trader::FybDatabase::My_Trade_History::RecordWithId& record, Poco::Data::AbstractBinder::Ptr pBinder, Poco::Data::AbstractBinder::Direction dir)
    {
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.ticket , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateCreated , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.dateExecuted , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.qty , pBinder, dir);
        Poco::Data::TypeHandler<double>::bind(pos++, record.price , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.status , pBinder, dir);
        Poco::Data::TypeHandler<std::string>::bind(pos++, record.type , pBinder, dir);
        Poco::Data::TypeHandler<Poco::Int32>::bind(pos++, record.id, pBinder, dir);
    }
    
    static void extract(std::size_t pos, trader::FybDatabase::My_Trade_History::RecordWithId& record, trader::FybDatabase::My_Trade_History::RecordWithId& deflt, Poco::Data::AbstractExtractor::Ptr pExtr)
    {
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.ticket, deflt.ticket, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateCreated, deflt.dateCreated, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.dateExecuted, deflt.dateExecuted, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.qty, deflt.qty, pExtr);
        Poco::Data::TypeHandler<double>::extract(pos++, record.price, deflt.price, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.status, deflt.status, pExtr);
        Poco::Data::TypeHandler<std::string>::extract(pos++, record.type, deflt.type, pExtr);
        Poco::Data::TypeHandler<Poco::Int32>::extract(pos++, record.id, deflt.id, pExtr);
    }
    
    static void prepare(std::size_t pos, trader::FybDatabase::My_Trade_History::RecordWithId& record, Poco::Data::AbstractPreparator::Ptr pPrep)
    {
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.ticket, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateCreated, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.dateExecuted, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.qty, pPrep);
        Poco::Data::TypeHandler<double>::prepare(pos++, record.price, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.status, pPrep);
        Poco::Data::TypeHandler<std::string>::prepare(pos++, record.type, pPrep);
        Poco::Data::TypeHandler<Poco::Int32>::prepare(pos++, record.id, pPrep);
    }
}
;