← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mysql-workbench/quantal

« back to all changes in this revision

Viewing changes to backend/wbpublic/objimpl/db/db_ForeignKey.cpp

  • Committer: Package Import Robot
  • Author(s): Dmitry Smirnov
  • Date: 2012-03-01 21:57:30 UTC
  • Revision ID: package-import@ubuntu.com-20120301215730-o7y8av8y38n162ro
Tags: upstream-5.2.38+dfsg
Import upstream version 5.2.38+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/wbpublic/objimpl/db/db_ForeignKey.cpp
 
1
#include "stdafx.h"
 
2
 
 
3
#include <grts/structs.db.h>
 
4
 
 
5
#include <grtpp_util.h>
 
6
#include <grtpp_undo_manager.h>
 
7
 
 
8
//================================================================================
 
9
// db_ForeignKey
 
10
 
 
11
 
 
12
// don't hold reference to the fk!
 
13
static std::map<grt::internal::Value*, std::set<db_ForeignKey*> > referenced_table_to_fk;
 
14
 
 
15
 
 
16
void db_ForeignKey::init()
 
17
{
 
18
}
 
19
 
 
20
 
 
21
static void delete_mapping(const db_TableRef &table, db_ForeignKey *fk)
 
22
{
 
23
  if (table.is_valid())
 
24
  {
 
25
    grt::internal::Value *t= table.valueptr();
 
26
    std::map<grt::internal::Value*, std::set<db_ForeignKey*> >::iterator iter= referenced_table_to_fk.find(t);
 
27
 
 
28
    if (iter != referenced_table_to_fk.end())
 
29
    {
 
30
      iter->second.erase(iter->second.find(fk));
 
31
 
 
32
      // if no more FKs to this table, remove the entry
 
33
      if (iter->second.empty())
 
34
        referenced_table_to_fk.erase(iter);
 
35
    }
 
36
  }
 
37
}
 
38
 
 
39
db_ForeignKey::~db_ForeignKey()
 
40
{
 
41
  delete_mapping(_referencedTable, this); 
 
42
}
 
43
 
 
44
 
 
45
 
 
46
grt::ListRef<db_ForeignKey> get_foreign_keys_referencing_table(const db_TableRef &value)
 
47
{
 
48
  std::map<grt::internal::Value*, std::set<db_ForeignKey*> >::const_iterator iter;
 
49
  grt::ListRef<db_ForeignKey> result(value.get_grt());
 
50
 
 
51
  if ((iter= referenced_table_to_fk.find(value.valueptr())) != referenced_table_to_fk.end())
 
52
  {
 
53
    for (std::set<db_ForeignKey*>::const_iterator fk= iter->second.begin();
 
54
      fk != iter->second.end(); ++fk)
 
55
    {
 
56
      result.insert(db_ForeignKeyRef(*fk));
 
57
    }
 
58
  }
 
59
  return result;
 
60
}
 
61
 
 
62
 
 
63
void db_ForeignKey::referencedTable(const db_TableRef &value)
 
64
{
 
65
  grt::ValueRef ovalue(_referencedTable);
 
66
 
 
67
  // remove old referenced table from backreference map
 
68
  delete_mapping(_referencedTable, this);
 
69
 
 
70
  _referencedTable= value;
 
71
 
 
72
  // add new referenced table to backreference map
 
73
  if (_referencedTable.is_valid())
 
74
  {
 
75
    std::set<db_ForeignKey*> list;
 
76
    std::map<grt::internal::Value*, std::set<db_ForeignKey*> >::iterator iter;
 
77
 
 
78
    if ((iter= referenced_table_to_fk.find(_referencedTable.valueptr())) != referenced_table_to_fk.end())
 
79
    {
 
80
      iter->second.insert(this);
 
81
    }
 
82
    else
 
83
    {
 
84
      list.insert(this);
 
85
      referenced_table_to_fk[_referencedTable.valueptr()]= list;
 
86
    }
 
87
  }
 
88
 
 
89
  member_changed("referencedTable", ovalue, value);
 
90
 
 
91
  if (_owner.is_valid())
 
92
    (*owner()->signal_foreignKeyChanged())(this);
 
93
}
 
94
 
 
95
 
 
96
 
 
97
void db_ForeignKey::owner(const db_TableRef &value)
 
98
{
 
99
  super::owner(value);
 
100
 
 
101
  if (value.is_valid())
 
102
    (*value->signal_foreignKeyChanged())(this);
 
103
}
 
104
 
 
105
 
 
106
void db_ForeignKey::owned_list_item_added(grt::internal::OwnedList *list, const grt::ValueRef &value)
 
107
{
 
108
  super::owned_list_item_added(list, value);
 
109
 
 
110
  if (_owner.is_valid())
 
111
    (*owner()->signal_foreignKeyChanged())(this);
 
112
}
 
113
 
 
114
 
 
115
void db_ForeignKey::owned_list_item_removed(grt::internal::OwnedList *list, const grt::ValueRef &value)
 
116
{
 
117
  super::owned_list_item_removed(list, value);
 
118
  
 
119
  if (_owner.is_valid())
 
120
    (*owner()->signal_foreignKeyChanged())(this);
 
121
}
 
122
 
 
123
 
 
124
 
 
125
/** Performs basic validation of the foreign key
 
126
 */
 
127
grt::IntegerRef db_ForeignKey::checkCompleteness()
 
128
{
 
129
  if (!_owner.is_valid() || !_referencedTable.is_valid())
 
130
    return 0;
 
131
 
 
132
  // If we are currently undoing then don't check completeness either.
 
133
  grt::UndoManager *um= get_grt()->get_undo_manager();
 
134
  if (um != NULL && um->is_undoing())
 
135
    return 0;
 
136
 
 
137
  if (db_TableRef::cast_from(_owner)->foreignKeys().get_index(db_ForeignKeyRef(this)) == grt::BaseListRef::npos)
 
138
    return 0;
 
139
 
 
140
  if (_columns.count() != _referencedColumns.count())
 
141
    return 0;
 
142
 
 
143
  for (size_t i= 0, c= _columns.count(); i < c; i++)
 
144
  {
 
145
    if (!_columns[i].is_valid() || !_referencedColumns[i].is_valid())
 
146
      return 0;
 
147
  }
 
148
 
 
149
  return 1;
 
150
}
 
151
 
 
152