class TSQLFile: public TFile

 default TSQLFile constructor

 Connects to SQL server with provided arguments.
 If the constructor fails in any way IsZombie() will
 return true. Use IsOpen() to check if the file is (still) open.

 If option = NEW or CREATE   create a ROOT tables in database
                             if the tables already exists connection is
                             not opened.
           = RECREATE        create completely new tables. Any existing tables
                             will be deleted
           = UPDATE          open an existing database for writing.
                             If data base open by other TSQLFile instance for writing,
                             write access will be rejected
           = BREAKLOCK       Special case when lock was not correctly released
                             by TSQLFile instance. This may happen if program crashed when
                             TSQLFile was open with write access mode.
           = READ or OPEN    open an existing data base for reading.

 For more details see comments for TFile::TFile() constructor

 For a moment TSQLFile does not support TTree objects and subdirectories

 start logging of all SQL statements in specified file

 close logging file

 checks, if MySQL database

 checks, if Oracle database

 checks, if ODBC driver used for database connection

 enable/disable uasge of suffixes in columns names
 can be changed before first object is saved into file

 Defines maximum number of columns for array representation
 If array size bigger than limit, array data will be converted to raw format
 This is usefull to prevent tables with very big number of columns
 If limit==0, all arrays will be stored in raw format
 If limit<0, all array values will be stored in column form
 Default value is 21

 Defines tables type, which is used in CREATE TABLE statements
 Now is only used for MySQL database, where following types are supported:
    "BDB", "HEAP", "ISAM", "InnoDB", "MERGE", "MRG_MYISAM", "MYISAM"
 Default for TSQLFile is "InnoDB". For more detailes see MySQL docs.

 Defines usage of transactions statements for writing objects data to database.
    kTransactionsOff=0   - no transaction operation are allowed
    kTransactionsAuto=1  - automatic mode. Each write operation,
        produced by TSQLFile, will be supplied by START TRANSACTION and COMMIT calls.
        If any error happen, ROLLBACK will returns database to previous state
    kTransactionsUser=2  - transactions are delegated to user. Methods
        StartTransaction(), Commit() and Rollback() should be called by user.
 Default UseTransactions option is kTransactionsAuto

 Start user transaction.
 This can be usesfull, when big number of objects should be stored in
 data base and commitment required only if all operations were succesfull.
 In that case in the end of all operations method Commit() should be
 called. If operation on user-level is looks like not successfull,
 method Rollback() will return database data and TSQLFile instance to
 previous state.
 In MySQL not all tables types support transaction mode of operation.
 See SetTablesType() method for details .

 Commit transaction, started by StartTransaction() call.
 Only after that call data will be written and visible on database side.

 Rollback all operations, done after StartTransaction() call.
 Database should return to initial state.

 Specify usage of indexes for data tables
    kIndexesNone = 0  - no indexes are used
    kIndexesBasic = 1 - indexes used only for keys list and
                        objects list tables (default)
    kIndexesClass = 2 - index also created for every normal class table
    kIndexesAll = 3   - index created for every table, including _streamer_ tables
 Indexes in general should increase speed of access to objects data,
 but they required more operations and more disk space on server side

 Return name of data base on the host
 For Oracle always return 0

 Close a SQL file
 For more comments see TFile::Close() function

 destructor of TSQLFile object

 make private to exclude copy operator

 return kTRUE if file is opened and can be accessed

 Reopen a file with a different access mode, like from READ to
 See TFile::Open() for details

 create SQL key, which will store object in data base

 create SQL key, which will store object in data base

 Write file info like configurations, title, UUID and other

 Store all TVirtualStreamerInfo, used in file, in sql database

 write special kind of object like streamer infos or file itself
 keys for that objects should exist in tables but not indicated in list of keys,
 therefore users can not get them with TDirectoryFile::Get() method

 Read data of special kind of objects

 Read back streamer infos from database
 List of streamer infos is always stored with key:id 0,
 which is not shown in normal keys list

 save data which is not yet in Database
 Typically this is streamerinfos structures or

 read keys for specified directory (when update == kFALSE)
 or update value for modified keys when update == kTRUE
 Returns number of succesfully read keys or -1 if error

 initialize sql database and correspondent structures
 identical to TFile::Init() function

 read table configurations as special table

 Creates initial tables in database
 This is table with configurations and table with keys
 Function called once when first object is stored to the file.

 Update value of modify counter in config table
 Modify counter used to indicate that something was changed in database.
 It will be used when multiple instances of TSQLFile for the same data base
 will be connected.

 Produce SELECT statement which can be used to get all data
 of class cl in one SELECT statement
 This statement also can be used to create VIEW by command like
 mysql> CREATE VIEW TH1I_view AS $CLASSSELECT$
 Where $CLASSSELECT$ argument should be produced by call
   f->MakeSelectQuery(TH1I::Class());
 VIEWs supported by latest MySQL 5 and Oracle

 used by MakeClassSelectQuery method to add columns from table of
 class, specified by TVirtualStreamerInfo structure

 Checks if main keys table is existing

 Checkis, if lock is free in configuration tables

 Set locking mode for current database

 Return current locking mode for that file

 dummy, in future should check about read access to database

 submits query to SQL server
 if flag==0, result is not interesting and will be deleted
 if flag==1, return result of submitted query
 if flag==2, results is may be necessary for long time
             Oracle plugin do not support working with several TSQLResult
             objects, therefore explicit deep copy will be produced
 If ok!=0, it will contains kTRUE is Query was successfull, otherwise kFALSE

 Test if DB support statement and number of open statements is not exceeded

 Produces SQL statement for currently conected DB server

 delete statement and decrease counter

 supplies set of commands to server
 Commands is stored as array of TObjString

 Test, if table of specified name exists

 Returns maximum value, found in specified columnname of table tablename
 Column type should be numeric

 Delete all tables in database

 Start SQL transaction.

 Commit SQL transaction

 Rollback all SQL operations, done after start transaction

 returns maximum allowed length of identifiers

 remove key with specified id from keys table
 also removes all objects data, related to this table

 Search for TKeySQL object with specified keyid

 add entry into keys table

 updates (overwrites) key data in KeysTable

 Returns next possible key identifier

 return (if exists) TSQLClassInfo for specified class name and version

 return (if exists) TSQLClassInfo for specified class

 search in database tables for specified class and return TSQLClassInfo object

 proposes table name for class

 test if table name exists

 search in database tables for specified class and return TSQLClassInfo object

 Read all class infos from IdsTable

 Add entry into IdsTable, where all tables names and columns names are listed

 Create normal class table if required

create the raw table

 Checks that table for big strings is exists
 If not, will be created

 produces id which will be placed in column instead of string itself

 checks if this is long string code
 returns 0, if not or string id

 returns value of string, extracted from special table,
 where long strings are stored

 Checks that objects table is exists
 If not, table will be created
 Returns maximum value for existing objects id

 Read from objects table data for specified objectid

 Produce array of TSQLObjectInfo objects for all objects, belong to that key
 Array should be deleted by calling function afterwards

 Method return request result for specified objid from normal classtable

 return data for several objects from the range from normal class table

  Method return request results for specified objid from _streamer_ classtable

  Method return request results for specified objid from _streamer_ classtable
  Data returned in form of statement, where direct access to values are possible

 Store object in database. Return stored object id or -1 if error

 returns sql type name which is most closer to ROOT basic type
 typ should be from TVirtualStreamerInfo:: constansts like TVirtualStreamerInfo::kInt

 return SQL integer type

 Create entry for directory in database

 Read directory list of keys from database

 Write directory keys list to database

 Update dir header in the file

 streamer for TSQLFile class
 stores only data for TDirectory

 Interface to basic system I/O routines, suppressed

 configuration of SQL