← Back to branch summary

~jaypipes/drizzle/bug534806

« back to all changes in this revision

Viewing changes to drizzled/replication_services.cc

  • Committer: Brian Aker
  • Date: 2010-03-03 05:02:36 UTC
  • mfrom: (1309.2.19 build)
  • Revision ID: brian@gaz-20100303050236-y7dotibgwks12gyp
Merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/replication_services.cc
508
508
     * We add the "key field metadata" -- i.e. the fields which is
509
509
     * the primary key for the table.
510
510
     */
511
 
    if (in_table->s->primary_key == current_field->field_index)
 
511
    if (in_table->s->fieldInPrimaryKey(current_field))
512
512
    {
513
513
      field_metadata= header->add_key_field_metadata();
514
514
      field_metadata->set_name(current_field->field_name);
602
602
     * primary key field value.  Replication only supports tables
603
603
     * with a primary key.
604
604
     */
605
 
    if (in_table->s->primary_key == current_field->field_index)
 
605
    if (in_table->s->fieldInPrimaryKey(current_field))
606
606
    {
607
607
      /**
608
608
       * To say the below is ugly is an understatement. But it works.
682
682
     * primary key field value.  Replication only supports tables
683
683
     * with a primary key.
684
684
     */
685
 
    if (in_table->s->primary_key == current_field->field_index)
 
685
    if (in_table->s->fieldInPrimaryKey(current_field))
686
686
    {
687
687
      field_metadata= header->add_key_field_metadata();
688
688
      field_metadata->set_name(current_field->field_name);
715
715
     * primary key field value.  Replication only supports tables
716
716
     * with a primary key.
717
717
     */
718
 
    if (in_table->s->primary_key == current_field->field_index)
 
718
    if (in_table->s->fieldInPrimaryKey(current_field))
719
719
    {
720
720
      string_value= current_field->val_str(string_value);
721
721
      record->add_key_value(string_value->c_ptr(), string_value->length());
727
727
  }
728
728
}
729
729
 
 
730
void ReplicationServices::createTable(Session *in_session,
 
731
                                      const message::Table &table)
 
732
{
 
733
  if (! is_active)
 
734
    return;
 
735
  
 
736
  message::Transaction *transaction= getActiveTransaction(in_session);
 
737
  message::Statement *statement= transaction->add_statement();
 
738
 
 
739
  initStatement(*statement, message::Statement::CREATE_TABLE, in_session);
 
740
 
 
741
  /* 
 
742
   * Construct the specialized CreateTableStatement message and attach
 
743
   * it to the generic Statement message
 
744
   */
 
745
  message::CreateTableStatement *create_table_statement= statement->mutable_create_table_statement();
 
746
  message::Table *new_table_message= create_table_statement->mutable_table();
 
747
  *new_table_message= table;
 
748
 
 
749
  finalizeStatement(*statement, in_session);
 
750
 
 
751
  finalizeTransaction(*transaction, in_session);
 
752
  
 
753
  push(*transaction);
 
754
 
 
755
  cleanupTransaction(transaction, in_session);
 
756
 
 
757
}
 
758
 
 
759
void ReplicationServices::createSchema(Session *in_session,
 
760
                                       const message::Schema &schema)
 
761
{
 
762
  if (! is_active)
 
763
    return;
 
764
  
 
765
  message::Transaction *transaction= getActiveTransaction(in_session);
 
766
  message::Statement *statement= transaction->add_statement();
 
767
 
 
768
  initStatement(*statement, message::Statement::CREATE_SCHEMA, in_session);
 
769
 
 
770
  /* 
 
771
   * Construct the specialized CreateSchemaStatement message and attach
 
772
   * it to the generic Statement message
 
773
   */
 
774
  message::CreateSchemaStatement *create_schema_statement= statement->mutable_create_schema_statement();
 
775
  message::Schema *new_schema_message= create_schema_statement->mutable_schema();
 
776
  *new_schema_message= schema;
 
777
 
 
778
  finalizeStatement(*statement, in_session);
 
779
 
 
780
  finalizeTransaction(*transaction, in_session);
 
781
  
 
782
  push(*transaction);
 
783
 
 
784
  cleanupTransaction(transaction, in_session);
 
785
 
 
786
}
 
787
 
 
788
void ReplicationServices::dropSchema(Session *in_session, const string &schema_name)
 
789
{
 
790
  if (! is_active)
 
791
    return;
 
792
  
 
793
  message::Transaction *transaction= getActiveTransaction(in_session);
 
794
  message::Statement *statement= transaction->add_statement();
 
795
 
 
796
  initStatement(*statement, message::Statement::DROP_SCHEMA, in_session);
 
797
 
 
798
  /* 
 
799
   * Construct the specialized DropSchemaStatement message and attach
 
800
   * it to the generic Statement message
 
801
   */
 
802
  message::DropSchemaStatement *drop_schema_statement= statement->mutable_drop_schema_statement();
 
803
 
 
804
  drop_schema_statement->set_schema_name(schema_name);
 
805
 
 
806
  finalizeStatement(*statement, in_session);
 
807
 
 
808
  finalizeTransaction(*transaction, in_session);
 
809
  
 
810
  push(*transaction);
 
811
 
 
812
  cleanupTransaction(transaction, in_session);
 
813
}
 
814
 
 
815
void ReplicationServices::dropTable(Session *in_session,
 
816
                                    const string &schema_name,
 
817
                                    const string &table_name,
 
818
                                    bool if_exists)
 
819
{
 
820
  if (! is_active)
 
821
    return;
 
822
  
 
823
  message::Transaction *transaction= getActiveTransaction(in_session);
 
824
  message::Statement *statement= transaction->add_statement();
 
825
 
 
826
  initStatement(*statement, message::Statement::DROP_TABLE, in_session);
 
827
 
 
828
  /* 
 
829
   * Construct the specialized DropTableStatement message and attach
 
830
   * it to the generic Statement message
 
831
   */
 
832
  message::DropTableStatement *drop_table_statement= statement->mutable_drop_table_statement();
 
833
 
 
834
  drop_table_statement->set_if_exists_clause(if_exists);
 
835
 
 
836
  message::TableMetadata *table_metadata= drop_table_statement->mutable_table_metadata();
 
837
 
 
838
  table_metadata->set_schema_name(schema_name);
 
839
  table_metadata->set_table_name(table_name);
 
840
 
 
841
  finalizeStatement(*statement, in_session);
 
842
 
 
843
  finalizeTransaction(*transaction, in_session);
 
844
  
 
845
  push(*transaction);
 
846
 
 
847
  cleanupTransaction(transaction, in_session);
 
848
}
 
849
 
730
850
void ReplicationServices::truncateTable(Session *in_session, Table *in_table)
731
851
{
732
852
  if (! is_active)