These methods are focused on reducing the amount of code you 
have to write to get stuff done using the QuickBase::Client.

1. def addOrEditRecord( dbid, fvlist, rid = nil, disprec = nil, fform = nil, ignoreError = nil, update_id = nil )
   Use this if you aren't sure whether a particular record already exists or not.
2. def getRecord(rid, dbid = @dbid)
   Get a record as a Hash, using the record id and dbid .
3. def iterateDBPages(dbid)
   Loop through the list of Pages for an application.
4. def getDBPagesAsArray(dbid)
   Get an array Pages for an application. Each item in the array is a Hash.
5. def Client.processDatabase( username, password, appname, chainAPIcalls = nil )

   This class method 
   
      - creates a QuickBase::Client, 
      - signs into QuickBase 
      - connects to a specific application
      - runs code in the associated block 
      - signs out of QuickBase
      
   e.g. QuickBase::Client.processDatabase( "user", "password", "my DB" ) { |qbClient,dbid| qbClient.getDBInfo( dbid ) }
   

6. def chainAPIcallsBlock()

   This method changes all the API_ wrapper methods to return 'self' instead of their
   normal return values. The change is in effect only within the associated block.  
   This allows mutliple API_ calls to be 'chained' together without needing 'qbClient' in front of each call.  
   
   e.g. qbClient.chainAPIcallsBlock { 
             qbClient
                .addField( @dbid, "a text field", "text" )
                .addField( @dbid, "a choice field", "text" )
                .fieldAddChoices( @dbid, @fid, %w{ one two three four five } )  
         }
   

7. def setActiveRecord( dbid, rid )
   Set the active database and record for subsequent method calls.
8. def setFieldValue( fieldName, fieldValue )
   Change a named field's value in the active record.
   e.g. setFieldValue( "Location", "Miami" )
9. def setFieldValues( fields )
   Change several named fields' values in the active record, e.g. setFieldValue( {"Location" => "Miami", "Phone" => "343-4567" } )
10. def changeRecords( fieldNameToSet, fieldValueToSet, fieldNameToTest, test, fieldValueToTest )

    Change a field's value in multiple records.   
    If the optional test field/operator/value are supplied, only records matching the test    
    field will be modified, otherwise all records will be modified. 
    
    e.g. changeRecords( "Status", "special", "Account Balance", ">", "100000.00" )
    
    

11. def deleteRecords( fieldNameToTest = nil, test = nil, fieldValueToTest = nil)

    Delete all records in the active table that match 
    the field/operator/value. e.g. deleteRecords( "Status", "==", "inactive" ).
    To delete ALL records, call deleteRecords() with no parameters. 
    This is the same as calling _purgeRecords.
    

12. def getAllValuesForFields( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Get all the values for one or more fields from a specified table.
    e.g. getAllValuesForFields( "dhnju5y7", [ "Name", "Phone" ] )
    The results are returned in Hash, e.g. { "Name" => values[ "Name" ], "Phone" => values[ "Phone" ] }
    The parameters after 'fieldNames' are passed directly to the doQuery() API_ call.
    

13. def getAllValuesForFieldsAsArray( dbid, fieldNames = nil, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Get all the values for one or more fields from a specified table, as an Array of records.
    This also formats the field values instead of returning the raw value.
    

14. def editRecords(dbid,fieldValuesToSet,query=nil,qid=nil,qname=nil)

    Set the values of fields in all records returned by a query.
    fieldValuesToSet must be a Hash of fieldnames+values, e.g. {"Location" => "Miami", "Phone" => "343-4567"}
    

15. def iterateRecords( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Loop through records returned from a query. Each record is a field+value Hash.
    e.g. iterateRecords( "dhnju5y7", ["Name","Address"] ) { |values| puts values["Name"], values["Address"] }
    

16. def iterateFilteredRecords( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Same as iterateRecords but with fields optionally filtered by Ruby regular expressions.
    e.g. iterateFilteredRecords( "dhnju5y7", [{"Name" => "[A-E].+}","Address"] ) { |values| puts values["Name"], values["Address"] }
    

17. def getFilteredRecords( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    e.g. getFilteredRecords( "dhnju5y7", [{"Name" => "[A-E].+}","Address"] ) { |values| puts values["Name"], values["Address"] }
    

18. def iterateJoinRecords(tablesAndFields)

    Get records from two or more tables and/or queries with the same value in a 
    'join' field and loop through the joined results.
    The 'joinfield' does not have to have the same name in each table.
    Fields with the same name in each table will be merged, with the value from the last 
    table being assigned. This is similar to an SQL JOIN.
    

19. def getJoinRecords(tablesAndFields)

    Get an array of records from two or more tables and/or queries with the same value in a 'join' field.
    The 'joinfield' does not have to have the same name in each table.
    Fields with the same name in each table will be merged, with the value from the last 
    table being assigned. This is similar to an SQL JOIN.
    

20. def iterateUnionRecords(tables,fieldNames)

    Get values from the same fields in two or more tables and/or queries and loop through the merged results.
    The merged records will be unique. This is similar to an SQL UNION.
    

21. def getUnionRecords(tables,fieldNames)

    Returns an Array of values from the same fields in two or more tables and/or queries.
    The merged records will be unique. This is similar to an SQL UNION.
    

22. def iterateSummaryRecords( dbid, fieldNames,query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    (The QuickBase API does not supply a method for this.) 
    Loop through summary records, like the records in a QuickBase Summary report.
    Fields with 'Total' and 'Average' checked in the target table will be summed and/or averaged.
    Other fields with duplicate values will be merged into a single 'record'.
    The results will be sorted by the merged fields, in ascending order.
     e.g. -  
        iterateSummaryRecords( "vavaa4sdd", ["Customer", "Amount"] ) {|record| 
           puts "Customer: #{record['Customer']}, Amount #{record['Amount']}
        } 
     would print the total Amount for each Customer, sorted by Customer.
    

23. def getSummaryRecords( dbid, fieldNames,query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Same as iterateSummaryRecords, but returns an array of records to be processed
    without necessarily looping through the records.
    

24. def iterateRecordInfos(dbid, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil)

    Loop through a list of records returned from a query. 
    Each record will contain all the fields with values formatted for readability by QuickBase via API_GetRecordInfo.
    This is much slower than iterateRecords() because it every record is read in a separate call to QuickBase.
    

25. def processRESTRequest(requestString)

    Returns table or record values using REST syntax. e.g. -
    puts processRESTRequest("8emtadvk/24105") # prints record 24105 from Community Forum
    puts processRESTRequest("8emtadvk") # prints name of table with dbid of '8emtadvk'
    puts qbc.processRESTRequest("6ewwzuuj/Function Name") # prints list of QuickBase Functions
    

26. def min( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Find the lowest value for one or more fields in the records returned by a query.
    e.g. minimumsHash = min("dfdfafff",["Date Sent","Quantity","Part Name"])
    

27. def max( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Find the lowest value for one or more fields in the records returned by a query.
    e.g. minimumsHash = min("dfdfafff",["Date Sent","Quantity","Part Name"])
    

28. def count( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Returns the number non-null values for one or more fields in the records returned by a query.
    e.g. countsHash = count("dfdfafff",["Date Sent","Quantity","Part Name"])
    

29. def sum( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Returns the sum of the values for one or more fields in the records returned by a query.
    e.g. sumsHash = sum("dfdfafff",["Date Sent","Quantity","Part Name"])
    

30. def average( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )

    Returns the average of the values for one or more fields in the records returned by a query.
    e.g. averagesHash = sum("dfdfafff",["Date Sent","Quantity","Part Name"])
    

31. def applyPercentToRecords( dbid, numericField, percentField, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil)

    Query records, sum the values in a numeric field, calculate each record's percentage 
    of the sum and put the percent in a percent field each record.
    

32. def applyDeviationToRecords( dbid, numericField, deviationField,

    Query records, get the average of the values in a numeric field, calculate each record's deviation
    from the average and put the deviation in a percent field each record.
    

33. def percent( inputValues )

    Given an array of two numbers, return the second number as a percentage of the first number
    

34. def deviation( inputValues )

    Given an array of two numbers, return the difference between the numbers as a positive number
    

35. def getFieldChoices(dbid,fieldName=nil,fid=nil)

    Get an array of the existing choices for a multiple-choice text field.
    

36. def getAllRecordIDs( dbid )

    Get an array of all the record IDs for a specified table.
    e.g. IDs = getAllRecordIDs( "dhnju5y7" ){ |id| puts "Record #{id}" }
    

37. def findDuplicateRecordIDs( fnames, fids, dbid = @dbid, ignoreCase = true )

    Finds records with the same values in a specified
    list of fields.  The field list may be a list of field IDs or a list of field names.
    Returns a hash with the structure { "duplicated values" => [ rid, rid, ... ] }
    

39. def deleteDuplicateRecords( fnames, fids = nil, options = nil, dbid = @dbid )

    Finds records with the same values in a specified
    list of fields and deletes all but the first or last duplicate record.
    The field list may be a list of field IDs or a list of field names.
    The 'options' parameter can be used to keep the oldest record instead of the
    newest record, and to control whether to ignore the case of field values when
    deciding which records are duplicates.  Returns the number of records deleted.
    

40. def copyRecord( rid, numCopies = 1, dbid = @dbid )

    Make one or more copies of a record.
    

41. def importFromExcel( dbid, excelFilename, lastColumn = 'j', lastDataRow = 0, worksheetNumber = 1, fieldNameRow = 1, firstDataRow = 2, firstColumn = 'a' )

    Import data directly from an Excel file into a table. The field names are expected to be on line 1 by default.
    By default, data will be read starting from row 2 and ending on the first empty row. 
    Commas in field values will be converted to semi-colons.
    e.g. importFromExcel( @dbid, "my_spreadsheet.xls", 'h' )
    

42. def importCSVFile( filename, dbid = @dbid, targetFieldNames = nil )

    Add records from lines in a CSV file. If dbid is not specified, the active table will be used. 
    values in subsequent lines.  The file must not contain commas inside field names or values.
    

43. def importTSVFile( filename, dbid = @dbid, targetFieldNames = nil )

    Import records from a text file in Tab-Separated-Values format.
    

44. def importSVFile( filename, fieldSeparator = ",", dbid = @dbid, targetFieldNames = nil )

    Add records from lines in a separated values text file, using  a specified field name/value separator.
    
     e.g. importSVFile( "contacts.txt", "::", "dhnju5y7", [ "Name", "Phone", "Email" ] )
      
     If targetFieldNames is not specified, the first line in the file
     must be a list of field names that match the values in subsequent lines.  
     
     If there are no commas in any of the field names or values, the file will be 
     treated as if it were a CSV file and imported using the QuickBase importFromCSV API call.
     Otherwise, records will be added using addRecord() for each line. 
     Lines with the wrong number of fields will be skipped.
     Double-quoted fields can contain the field separator, e.g. f1,"f,2",f3
     Spaces will not be trimmed from the beginning or end of field values.
    

45. def uploadFile( dbid, filename, fileAttachmentFieldName, additionalFieldsToSet = nil )

    Upload a file into a new record in a table. Additional field values can optionally be set.
    e.g. uploadFile( "dhnju5y7", "contacts.txt", "Contacts File", { "Notes" => "#{Time.now}" }
    

46. def updateFile( dbid, rid, filename, fileAttachmentFieldName, additionalFieldsToSet = nil )

    Update the file attachment in an existing record in a table. Additional field values can optionally be set.
    e.g. updateFile( "dhnju5y7", "6", "contacts.txt", "Contacts File", { "Notes" => "#{Time.now}" }
    

47. def logToFile( filename )

    Log requests to QuickBase and responses from QuickBase in a file.
    Useful for utilities that run unattended.
    

48. def eachRecord( records = @records )

    Iterate @records XML and yield only <record> elements.
    

49. def doSQLInsert(sqlString)

    Translate a simple SQL INSERT statement to a QuickBase addRecord call.
    Note: This method is here primarily for Rails integration.
    Note: This assumes, like SQL, that your column (i.e. field) names do not contain spaces.
    

50. def doSQLUpdate(sqlString)

    Translate a simple SQL UPDATE statement to a QuickBase editRecord call.
    Note: This method is here primarily for Rails integration.
    Note: This assumes, like SQL, that your column (i.e. field) names do not contain spaces.
    Note: This assumes that Record ID# is the key field in your table.
    

51. def doSQLQuery( sqlString, returnOptions = nil )

    Translate a simple SQL SELECT statement to a QuickBase query and run it.
     
    If any supplied field names are numeric, they will be treated as QuickBase field IDs if
    they aren't valid field names. 
    
    e.g. doSQLQuery( "SELECT FirstName,Salary FROM Contacts WHERE LastName = "Doe" ORDER BY FirstName )
    e.g. doSQLQuery( "SELECT * FROM Books WHERE Author = "Freud" )
    
    Note: This method is here primarily for Rails integration.
    Note: This assumes, like SQL, that your column (i.e. field) names do not contain spaces.
    

These methods implement the core functionality to make the API_ wrapper methods
and Helper methods work.  Most programs will not need to use these methods directly 
and should avoid doing so.

To subscribe to events fired by the Client class, derive from this 
class, override handle( event ), and call subscribe( event, self ).  
See Client.subscribe() for a list of events.

To log QuickBase requests and responses to a file, make an instance
of this class and call Client.setLogger( loggerInstance ).
Call Client.setLogger( nil ) to turn logging off.
The log file is written in CSV format to make it importable by QuickBase.

This implements an extensible command line interface to QuickBase.
Use setCommand() and setCommandAlias() to extend or modify the interface. 

Call run() to use the command line interactively.
Call run( filename ) to run the commands in a file.  
Commands entered during an interactive session can be recorded to a file.

In addition to the @commands loaded in initialize(), any public method 
from class Client can be used as a command, and any line of ruby code 
can be executed.

A web server that responds to requests to run command files 
present on the local machine. This extends QuickBase via URLs on web pages.

e.g. if there is an 'uploadSpreadsheet.qbc' command file next to this QuickBaseClient.rb 
file on your machine, it can be run from a web page by starting 'WebClient.new' on your 
machine and placing 'http://127.0.0.1:2358/qbc/uploadSpreadsheet.qbc' in a link on the
web page.
  
Any request that does not include "/qbc/" will shut down the server.