← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_share.cc

  • Committer: Brian Aker
  • Date: 2010-10-20 20:26:18 UTC
  • mfrom: (1859.2.13 refactor)
  • Revision ID: brian@tangent.org-20101020202618-9222n39lm329urv5
Merge for Brian 

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_share.cc
44
44
#include "drizzled/internal/my_pthread.h"
45
45
#include "drizzled/plugin/event_observer.h"
46
46
 
 
47
#include "drizzled/table.h"
 
48
#include "drizzled/table/shell.h"
 
49
 
47
50
#include "drizzled/session.h"
48
51
 
49
52
#include "drizzled/charset.h"
1444
1447
 
1445
1448
    // This needs to go, we should be setting the "use" on the field so that
1446
1449
    // it does not reference the share/table.
1447
 
    Table temp_table; /* Use this so that BLOB DEFAULT '' works */
1448
 
    temp_table.setShare(this);
 
1450
    table::Shell temp_table(*this); /* Use this so that BLOB DEFAULT '' works */
1449
1451
    temp_table.in_use= &session;
1450
1452
 
1451
1453
    f->init(&temp_table); /* blob default values need table obj */
1825
1827
  5    Error (see open_table_error: charset unavailable)
1826
1828
  7    Table definition has changed in engine
1827
1829
*/
1828
 
 
1829
1830
int TableShare::open_table_from_share(Session *session,
1830
1831
                                      const TableIdentifier &identifier,
1831
1832
                                      const char *alias,
1832
1833
                                      uint32_t db_stat, uint32_t ha_open_flags,
1833
1834
                                      Table &outparam)
1834
1835
{
 
1836
  bool error_reported= false;
 
1837
  int ret= open_table_from_share_inner(session, alias, db_stat, ha_open_flags, outparam, error_reported);
 
1838
 
 
1839
  if (not ret)
 
1840
    ret= open_table_cursor_inner(session, identifier, alias, db_stat, ha_open_flags, outparam, error_reported);
 
1841
 
 
1842
  if (not ret)
 
1843
    return ret;
 
1844
 
 
1845
  if (not error_reported)
 
1846
    open_table_error(ret, errno, 0);
 
1847
 
 
1848
  delete outparam.cursor;
 
1849
  outparam.cursor= 0;                           // For easier error checking
 
1850
  outparam.db_stat= 0;
 
1851
  outparam.getMemRoot()->free_root(MYF(0));       // Safe to call on zeroed root
 
1852
  free((char*) outparam.alias);
 
1853
 
 
1854
  return ret;
 
1855
}
 
1856
 
 
1857
int TableShare::open_table_from_share_inner(Session *session,
 
1858
                                            const char *alias,
 
1859
                                            uint32_t db_stat, uint32_t ,
 
1860
                                            Table &outparam,
 
1861
                                            bool &)
 
1862
{
1835
1863
  int local_error;
1836
1864
  uint32_t records;
1837
 
  bool error_reported= false;
1838
1865
  unsigned char *record= NULL;
1839
1866
  Field **field_ptr;
1840
1867
 
1845
1872
  outparam.resetTable(session, this, db_stat);
1846
1873
 
1847
1874
  if (not (outparam.alias= strdup(alias)))
1848
 
    goto err;
 
1875
    return local_error;
1849
1876
 
1850
1877
  /* Allocate Cursor */
1851
1878
  if (not (outparam.cursor= db_type()->getCursor(*this)))
1852
 
    goto err;
 
1879
    return local_error;
1853
1880
 
1854
1881
  local_error= 4;
1855
1882
  records= 0;
1859
1886
  records++;
1860
1887
 
1861
1888
  if (!(record= (unsigned char*) outparam.alloc_root(rec_buff_length * records)))
1862
 
    goto err;
 
1889
    return local_error;
1863
1890
 
1864
1891
  if (records == 0)
1865
1892
  {
1895
1922
 
1896
1923
  if (!(field_ptr = (Field **) outparam.alloc_root( (uint32_t) ((fields+1)* sizeof(Field*)))))
1897
1924
  {
1898
 
    goto err;
 
1925
    return local_error;
1899
1926
  }
1900
1927
 
1901
1928
  outparam.setFields(field_ptr);
1908
1935
  for (uint32_t i= 0 ; i < fields; i++, field_ptr++)
1909
1936
  {
1910
1937
    if (!((*field_ptr)= field[i]->clone(outparam.getMemRoot(), &outparam)))
1911
 
      goto err;
 
1938
      return local_error;
1912
1939
  }
1913
1940
  (*field_ptr)= 0;                              // End marker
1914
1941
 
1927
1954
    uint32_t n_length;
1928
1955
    n_length= keys*sizeof(KeyInfo) + key_parts*sizeof(KeyPartInfo);
1929
1956
    if (!(local_key_info= (KeyInfo*) outparam.alloc_root(n_length)))
1930
 
      goto err;
 
1957
      return local_error;
1931
1958
    outparam.key_info= local_key_info;
1932
1959
    key_part= (reinterpret_cast<KeyPartInfo*> (local_key_info+keys));
1933
1960
 
1971
1998
  outparam.tmp_set.resize(fields);
1972
1999
  outparam.default_column_bitmaps();
1973
2000
 
 
2001
  return 0;
 
2002
}
 
2003
 
 
2004
int TableShare::open_table_cursor_inner(Session *,
 
2005
                                        const TableIdentifier &identifier,
 
2006
                                        const char *,
 
2007
                                        uint32_t db_stat, uint32_t ha_open_flags,
 
2008
                                        Table &outparam,
 
2009
                                        bool &error_reported)
 
2010
{
1974
2011
  /* The table struct is now initialized;  Open the table */
1975
 
  local_error= 2;
 
2012
  int local_error= 2;
1976
2013
  if (db_stat)
1977
2014
  {
1978
2015
    assert(!(db_stat & HA_WAIT_IF_LOCKED));
2007
2044
          local_error= 7;
2008
2045
        break;
2009
2046
      }
2010
 
      goto err;
 
2047
      return local_error;
2011
2048
    }
2012
2049
  }
2013
2050
 
2014
2051
  return 0;
2015
 
 
2016
 
err:
2017
 
  if (!error_reported)
2018
 
    open_table_error(local_error, errno, 0);
2019
 
 
2020
 
  delete outparam.cursor;
2021
 
  outparam.cursor= 0;                           // For easier error checking
2022
 
  outparam.db_stat= 0;
2023
 
  outparam.getMemRoot()->free_root(MYF(0));       // Safe to call on zeroed root
2024
 
  free((char*) outparam.alias);
2025
 
 
2026
 
  return (local_error);
2027
2052
}
2028
2053
 
2029
2054
/* error message when opening a form cursor */