← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/transaction_services.cc

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/transaction_services.cc
47
47
 * plugins can understand.
48
48
 */
49
49
 
50
 
#include <config.h>
51
 
#include <drizzled/current_session.h>
52
 
#include <drizzled/my_hash.h>
53
 
#include <drizzled/error.h>
54
 
#include <drizzled/gettext.h>
55
 
#include <drizzled/probes.h>
56
 
#include <drizzled/sql_parse.h>
57
 
#include <drizzled/session.h>
58
 
#include <drizzled/sql_base.h>
59
 
#include <drizzled/replication_services.h>
60
 
#include <drizzled/transaction_services.h>
61
 
#include <drizzled/transaction_context.h>
62
 
#include <drizzled/message/transaction.pb.h>
63
 
#include <drizzled/message/statement_transform.h>
64
 
#include <drizzled/resource_context.h>
65
 
#include <drizzled/lock.h>
66
 
#include <drizzled/item/int.h>
67
 
#include <drizzled/item/empty_string.h>
68
 
#include <drizzled/field/epoch.h>
69
 
#include <drizzled/plugin/client.h>
70
 
#include <drizzled/plugin/monitored_in_transaction.h>
71
 
#include <drizzled/plugin/transactional_storage_engine.h>
72
 
#include <drizzled/plugin/xa_resource_manager.h>
73
 
#include <drizzled/plugin/xa_storage_engine.h>
74
 
#include <drizzled/internal/my_sys.h>
 
50
#include "config.h"
 
51
#include "drizzled/my_hash.h"
 
52
#include "drizzled/error.h"
 
53
#include "drizzled/gettext.h"
 
54
#include "drizzled/probes.h"
 
55
#include "drizzled/sql_parse.h"
 
56
#include "drizzled/session.h"
 
57
#include "drizzled/sql_base.h"
 
58
#include "drizzled/replication_services.h"
 
59
#include "drizzled/transaction_services.h"
 
60
#include "drizzled/transaction_context.h"
 
61
#include "drizzled/message/transaction.pb.h"
 
62
#include "drizzled/message/statement_transform.h"
 
63
#include "drizzled/resource_context.h"
 
64
#include "drizzled/lock.h"
 
65
#include "drizzled/item/int.h"
 
66
#include "drizzled/item/empty_string.h"
 
67
#include "drizzled/field/epoch.h"
 
68
#include "drizzled/plugin/client.h"
 
69
#include "drizzled/plugin/monitored_in_transaction.h"
 
70
#include "drizzled/plugin/transactional_storage_engine.h"
 
71
#include "drizzled/plugin/xa_resource_manager.h"
 
72
#include "drizzled/plugin/xa_storage_engine.h"
 
73
#include "drizzled/internal/my_sys.h"
75
74
 
76
75
#include <vector>
77
76
#include <algorithm>
1385
1384
  if (! replication_services.isActive())
1386
1385
    return false;
1387
1386
 
1388
 
  if (not table.getShare()->replicate())
1389
 
    return false;
1390
 
 
1391
1387
  /**
1392
1388
   * We do this check here because we don't want to even create a 
1393
1389
   * statement if there isn't a primary key on the table...
1583
1579
    }
1584
1580
  }
1585
1581
}
1586
 
 
1587
1582
void TransactionServices::updateRecord(Session::reference session,
1588
1583
                                       Table &table, 
1589
1584
                                       const unsigned char *old_record, 
1593
1588
  if (! replication_services.isActive())
1594
1589
    return;
1595
1590
 
1596
 
  if (not table.getShare()->replicate())
1597
 
    return;
1598
 
 
1599
1591
  uint32_t next_segment_id= 1;
1600
1592
  message::Statement &statement= getUpdateStatement(session, table, old_record, new_record, &next_segment_id);
1601
1593
 
1855
1847
  if (! replication_services.isActive())
1856
1848
    return;
1857
1849
 
1858
 
  if (not table.getShare()->replicate())
1859
 
    return;
1860
 
 
1861
1850
  uint32_t next_segment_id= 1;
1862
1851
  message::Statement &statement= getDeleteStatement(session, table, &next_segment_id);
1863
1852
 
1913
1902
  ReplicationServices &replication_services= ReplicationServices::singleton();
1914
1903
  if (! replication_services.isActive())
1915
1904
    return;
1916
 
 
1917
 
  if (table.has_options() and table.options().has_dont_replicate() and table.options().dont_replicate())
1918
 
    return;
1919
 
 
 
1905
  
1920
1906
  message::Transaction *transaction= getActiveTransactionMessage(session);
1921
1907
  message::Statement *statement= transaction->add_statement();
1922
1908
 
1946
1932
  ReplicationServices &replication_services= ReplicationServices::singleton();
1947
1933
  if (! replication_services.isActive())
1948
1934
    return;
1949
 
 
1950
 
  if (schema.has_replication_options() and schema.replication_options().has_dont_replicate() and schema.replication_options().dont_replicate())
1951
 
    return;
1952
 
 
 
1935
  
1953
1936
  message::Transaction *transaction= getActiveTransactionMessage(session);
1954
1937
  message::Statement *statement= transaction->add_statement();
1955
1938
 
1974
1957
}
1975
1958
 
1976
1959
void TransactionServices::dropSchema(Session::reference session,
1977
 
                                     identifier::Schema::const_reference identifier,
1978
 
                                     message::schema::const_reference schema)
 
1960
                                     identifier::Schema::const_reference identifier)
1979
1961
{
1980
1962
  ReplicationServices &replication_services= ReplicationServices::singleton();
1981
1963
  if (! replication_services.isActive())
1982
1964
    return;
1983
 
 
1984
 
  if (schema.has_replication_options() and schema.replication_options().has_dont_replicate() and schema.replication_options().dont_replicate())
1985
 
    return;
1986
 
 
 
1965
  
1987
1966
  message::Transaction *transaction= getActiveTransactionMessage(session);
1988
1967
  message::Statement *statement= transaction->add_statement();
1989
1968
 
2007
1986
}
2008
1987
 
2009
1988
void TransactionServices::alterSchema(Session::reference session,
2010
 
                                      const message::Schema &old_schema,
 
1989
                                      const message::schema::shared_ptr &old_schema,
2011
1990
                                      const message::Schema &new_schema)
2012
1991
{
2013
1992
  ReplicationServices &replication_services= ReplicationServices::singleton();
2014
1993
  if (! replication_services.isActive())
2015
1994
    return;
2016
 
 
2017
 
  if (old_schema.has_replication_options() and old_schema.replication_options().has_dont_replicate() and old_schema.replication_options().dont_replicate())
2018
 
    return;
2019
 
 
 
1995
  
2020
1996
  message::Transaction *transaction= getActiveTransactionMessage(session);
2021
1997
  message::Statement *statement= transaction->add_statement();
2022
1998
 
2031
2007
  message::Schema *before= alter_schema_statement->mutable_before();
2032
2008
  message::Schema *after= alter_schema_statement->mutable_after();
2033
2009
 
2034
 
  *before= old_schema;
 
2010
  *before= *old_schema;
2035
2011
  *after= new_schema;
2036
2012
 
2037
2013
  finalizeStatementMessage(*statement, session);
2044
2020
}
2045
2021
 
2046
2022
void TransactionServices::dropTable(Session::reference session,
2047
 
                                    identifier::Table::const_reference identifier,
2048
 
                                    message::table::const_reference table,
 
2023
                                    const identifier::Table &table,
2049
2024
                                    bool if_exists)
2050
2025
{
2051
2026
  ReplicationServices &replication_services= ReplicationServices::singleton();
2052
2027
  if (! replication_services.isActive())
2053
2028
    return;
2054
 
 
2055
 
  if (table.has_options() and table.options().has_dont_replicate() and table.options().dont_replicate())
2056
 
    return;
2057
 
 
 
2029
  
2058
2030
  message::Transaction *transaction= getActiveTransactionMessage(session);
2059
2031
  message::Statement *statement= transaction->add_statement();
2060
2032
 
2070
2042
 
2071
2043
  message::TableMetadata *table_metadata= drop_table_statement->mutable_table_metadata();
2072
2044
 
2073
 
  table_metadata->set_schema_name(identifier.getSchemaName());
2074
 
  table_metadata->set_table_name(identifier.getTableName());
 
2045
  table_metadata->set_schema_name(table.getSchemaName());
 
2046
  table_metadata->set_table_name(table.getTableName());
2075
2047
 
2076
2048
  finalizeStatementMessage(*statement, session);
2077
2049
 
2088
2060
  ReplicationServices &replication_services= ReplicationServices::singleton();
2089
2061
  if (! replication_services.isActive())
2090
2062
    return;
2091
 
 
2092
 
  if (not table.getShare()->replicate())
2093
 
    return;
2094
 
 
 
2063
  
2095
2064
  message::Transaction *transaction= getActiveTransactionMessage(session);
2096
2065
  message::Statement *statement= transaction->add_statement();
2097
2066
 
2106
2075
 
2107
2076
  string schema_name;
2108
2077
  (void) table.getShare()->getSchemaName(schema_name);
2109
 
 
2110
2078
  string table_name;
2111
2079
  (void) table.getShare()->getTableName(table_name);
2112
2080