Work with resulting set (VB, C++)

Function RowToStr(rs As ADODB.Recordset) As String
 Dim i As Long
 Dim str As String

 For i = 0 To rs.Fields.Count - 1
  str = str & MyCStr(rs(i)) & Chr(9)
 Next i
 RowToStr = str
End Function

Sub sample2()
 Dim cn As New ADODB.Connection
 cn.Open "file name=d:\database\employee.ibp"

 Dim i As Integer
 Dim str As String

 Dim cmd As New ADODB.Command
 Dim rs As ADODB.Recordset

 cmd.ActiveConnection = cn
 cmd.CommandText = "select * from employee order by emp_no"

 'Creation of recordset with the unidirectional access
 Set rs = cmd.Execute

 While Not rs.EOF
  Debug.Print RowToStr(rs)
  rs.MoveNext
 Wend

 Debug.Print "+++++++++++++++++++++++++++"
 rs.Close
 'Creation of recordset with the bidirectional access
 cmd.Properties("Fetch Backwards") = True
 cmd.Properties("Scroll Backwards") = True
 Set rs = cmd.Execute

 While (Not rs.EOF)
  Debug.Print RowToStr(rs)
  rs.MoveNext
 Wend

 Debug.Print "+++++++++++++++++++++++++++"

  rs.MovePrevious
 While (Not rs.BOF)
  Debug.Print RowToStr(rs)
  rs.MovePrevious
 Wend

 rs.Close

 Debug.Print "+++++++++++++++++++++++++++"
 'Creation of recordset with a direct access
 cmd.Properties("IRowsetLocate") = True
 Set rs = cmd.Execute

 'Printing of lines with the random order
 Dim cnt As Long
 ReDim flags(rs.RecordCount) As Boolean

 While (cnt <> rs.RecordCount)
  i = Int(Rnd(1) * rs.RecordCount)
  If (Not flags(i)) Then
   flags(i) = True
   cnt = cnt + 1

   rs.MoveFirst
   rs.Move i

   Debug.Print RowToStr(rs)
  End If
 Wend

End Sub

void TSampleCode2::execute()
{
 cout<<"Sample Code #2"<<endl;

 try
 {
  t_db_data_source source;
  t_db_session     session;

  //attach data source (auto commit mode)
  _THROW_OLEDB_FAILED(source,attach("file name=employee.ibp"))

  //create session
  _THROW_OLEDB_FAILED(session,create(source))

  //create rowset
  t_db_row         row;
  t_db_open_rowset rowset;

  _THROW_OLEDB_FAILED(rowset,create(session))

  cout<<"unidirectional access"<<endl; //---------------------------------

  _THROW_OLEDB_FAILED(rowset.m_props,set(t_db_prop_id::rowset_locate,false))
  _THROW_OLEDB_FAILED(rowset.m_props,set(t_db_prop_id::rowset_canfetchbackwards,false))
  _THROW_OLEDB_FAILED(rowset.m_props,set(t_db_prop_id::rowset_canscrollbackwards,false))

  //use read-only engine
  _THROW_OLEDB_FAILED(rowset.m_props,set(t_db_prop_id::rowset_change,false))

  //open table
  _THROW_OLEDB_FAILED(rowset,open_table("employee"))
  _THROW_OLEDB_FAILED(rowset,describe(row))
  _THROW_OLEDB_FAILED(rowset,bind(row))

  //retrive row
  while(rowset.fetch(row)==S_OK)
  {
   cout<<row_to_str(row)<<endl;
  }//while fetch

  //check last result of fetch
  _THROW_OLEDB_FAILED(rowset,m_last_result)

  cout<<endl<<"random access"<<endl; //----------------------

  //set "IRowsetScroll" property to true
  //provider must caching result set
  _THROW_OLEDB_FAILED(rowset.m_props,set(t_db_prop_id::rowset_scroll,true))

  //open table
  _THROW_OLEDB_FAILED(rowset,open_table("employee"))
  _THROW_OLEDB_FAILED(rowset,describe(row))
  _THROW_OLEDB_FAILED(rowset,bind(row))

  //get record count
  t_db_open_rowset::count_item_type ax_row_count;

  _THROW_OLEDB_FAILED(rowset,approximate_count(ax_row_count))

  cout<<"record count:"<<ax_row_count<<endl;

  //build random sequential move
  typedef structure::t_vector<t_db_open_rowset::count_item_type> row_num_vector;

  row_num_vector row_nums;

  row_nums.reserve(ax_row_count);

  for(t_db_open_rowset::count_item_type i=0;i<=ax_row_count;++i)
   row_nums.push_back(i);

  random_shuffle(row_nums.begin(),row_nums.end());

  rowset.cache_size=1;

  for(row_num_vector::const_iterator i_row(row_nums.begin()),_end(row_nums.end());
      i_row!=_end;++i_row)
  {
   _THROW_OLEDB_FAILED(rowset,restart())

   _THROW_OLEDB_FAILED(rowset,scroll(*i_row))

   _THROW_OLEDB_FAILED(rowset,fetch(row))

   cout<<row_to_str(row)<<endl;
  }//for i_row
 }
 catch(exception& exc)
 {
  cout<<"error: "<<exc.what()<<endl;
 }
}//execute