← Back to branch summary

~ubuntu-branches/ubuntu/karmic/firebird2.1/karmic

« back to all changes in this revision

Viewing changes to src/utilities/rebuild/rstore.epp

  • Committer: Bazaar Package Importer
  • Author(s): Damyan Ivanov
  • Date: 2008-05-26 23:59:25 UTC
  • Revision ID: james.westby@ubuntu.com-20080526235925-2pnqj6nxpppoeaer
Tags: upstream-2.1.0.17798-0.ds2
Import upstream version 2.1.0.17798-0.ds2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/utilities/rebuild/rstore.epp
 
1
/*
 
2
 *      PROGRAM:        JRD Rebuild scrambled database
 
3
 *      MODULE:         rstore.epp
 
4
 *      DESCRIPTION:    Store page headers for analysis
 
5
 *
 
6
 * The contents of this file are subject to the Interbase Public
 
7
 * License Version 1.0 (the "License"); you may not use this file
 
8
 * except in compliance with the License. You may obtain a copy
 
9
 * of the License at http://www.Inprise.com/IPL.html
 
10
 *
 
11
 * Software distributed under the License is distributed on an
 
12
 * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
 
13
 * or implied. See the License for the specific language governing
 
14
 * rights and limitations under the License.
 
15
 *
 
16
 * The Original Code was created by Inprise Corporation
 
17
 * and its predecessors. Portions created by Inprise Corporation are
 
18
 * Copyright (C) Inprise Corporation.
 
19
 *
 
20
 * All Rights Reserved.
 
21
 * Contributor(s): ______________________________________.
 
22
 */
 
23
 
 
24
#include "firebird.h"
 
25
#include "../jrd/ibase.h"
 
26
#include "../utilities/rebuild/rebuild.h"
 
27
#include "../utilities/rebuild/rebui_proto.h"
 
28
#include "../utilities/rebuild/rstor_proto.h"
 
29
#include "../jrd/gds_proto.h"
 
30
 
 
31
DATABASE DB = STATIC FILENAME "rebuild.fdb";
 
32
 
 
33
static void store_headers(RBDB);
 
34
 
 
35
 
 
36
void RSTORE( RBDB rbdb)
 
37
{
 
38
/**************************************
 
39
 *
 
40
 *      R S T O R E
 
41
 *
 
42
 **************************************
 
43
 *
 
44
 * Functional description
 
45
 *      write the contents of page headers
 
46
 *      into a database.
 
47
 *
 
48
 **************************************/
 
49
        READY
 
50
        ON_ERROR
 
51
                isc_print_status(gds__status);
 
52
                printf("can't open the documentaton database\n");
 
53
                FINISH;
 
54
                return;
 
55
        END_ERROR;
 
56
        START_TRANSACTION
 
57
        ON_ERROR
 
58
                isc_print_status(gds__status);
 
59
                printf("can't start a transaction on the documentaton database\n");
 
60
                FINISH;
 
61
                return;
 
62
        END_ERROR;
 
63
        store_headers(rbdb);
 
64
        COMMIT;
 
65
        FINISH;
 
66
}
 
67
 
 
68
 
 
69
static void store_headers( RBDB rbdb)
 
70
{
 
71
/**************************************
 
72
 *
 
73
 *      s t o r e _ h e a d e r s
 
74
 *
 
75
 **************************************
 
76
 *
 
77
 * Functional description
 
78
 *      write the contents of page headers
 
79
 *      into a database.
 
80
 *
 
81
 **************************************/
 
82
        PAG page;
 
83
        header_page* header;
 
84
        BLP blob;
 
85
        BTR bucket;
 
86
        DPG data;
 
87
        IRT index_root;
 
88
        page_inv_page* pip;
 
89
        PPG pointer;
 
90
        ISC_QUAD temp;
 
91
 
 
92
        ULONG page_number = 0;
 
93
 
 
94
        while (page = RBDB_read(rbdb, page_number)) {
 
95
                STORE P IN FULL_PAGES USING
 
96
                        {
 
97
                                P.NUMBER = page_number;
 
98
                                P.TYPE = page->pag_type;
 
99
                                P.FLAGS = page->pag_flags;
 
100
                                P.CHECKSUM = page->pag_checksum;
 
101
                                P.GENERATION = page->pag_generation;
 
102
                                P.RELATION.NULL = TRUE;
 
103
                                P.SEQUENCE.NULL = TRUE;
 
104
                                P.BLP_LEAD_PAGE.NULL = TRUE;
 
105
                                P.BLP_LENGTH.NULL = TRUE;
 
106
                                P.BTR_SIBLING.NULL = TRUE;
 
107
                                P.BTR_LENGTH.NULL = TRUE;
 
108
                                P.BTR_ID.NULL = TRUE;
 
109
                                P.BTR_LEVEL.NULL = TRUE;
 
110
                                P.DPG_COUNT.NULL = TRUE;
 
111
                                P.IRT_COUNT.NULL = TRUE;
 
112
                                P.HDR_PAGE_SIZE.NULL = TRUE;
 
113
                                P.HDR_ODS_VERSION.NULL = TRUE;
 
114
                                P.HDR_PAGES.NULL = TRUE;
 
115
                                P.HDR_OLDEST_TRANS.NULL = TRUE;
 
116
                                P.HDR_OLDEST_ACTIVE.NULL = TRUE;
 
117
                                P.HDR_NEXT_TRANS.NULL = TRUE;
 
118
                                P.HDR_FLAGS.NULL = TRUE;
 
119
                                P.HDR_CREATION_DATE.NULL = TRUE;
 
120
                                P.HDR_ATTACHMENT_ID.NULL = TRUE;
 
121
                                P.HDR_IMPLEMENTATION.NULL = TRUE;
 
122
                                P.HDR_SHADOW_COUNT.NULL = TRUE;
 
123
                                P.PIP_MIN.NULL = TRUE;
 
124
                                P.PPG_NEXT.NULL = TRUE;
 
125
                                P.PPG_COUNT.NULL = TRUE;
 
126
                                P.PPG_MIN_SPACE.NULL = TRUE;
 
127
                                P.PPG_MAX_SPACE.NULL = TRUE;
 
128
                                P.TIP_NEXT.NULL = TRUE;
 
129
 
 
130
 
 
131
                                switch (page->pag_type) {
 
132
                                case pag_header:
 
133
                                        header = (header_page*) page;
 
134
                                        P.HDR_PAGE_SIZE.NULL = FALSE;
 
135
                                        P.HDR_ODS_VERSION.NULL = FALSE;
 
136
                                        P.HDR_PAGES.NULL = FALSE;
 
137
                                        P.HDR_OLDEST_TRANS.NULL = FALSE;
 
138
                                        P.HDR_OLDEST_ACTIVE.NULL = FALSE;
 
139
                                        P.HDR_NEXT_TRANS.NULL = FALSE;
 
140
                                        P.SEQUENCE.NULL = FALSE;
 
141
                                        P.HDR_FLAGS.NULL = FALSE;
 
142
                                        P.HDR_CREATION_DATE.NULL = FALSE;
 
143
                                        P.HDR_ATTACHMENT_ID.NULL = FALSE;
 
144
                                        P.HDR_IMPLEMENTATION.NULL = FALSE;
 
145
                                        P.HDR_SHADOW_COUNT.NULL = FALSE;
 
146
                                        P.HDR_PAGE_SIZE = header->hdr_page_size;
 
147
                                        P.HDR_ODS_VERSION = header->hdr_ods_version;
 
148
                                        P.HDR_PAGES = header->hdr_PAGES;
 
149
                                        P.HDR_OLDEST_TRANS = header->hdr_oldest_transaction;
 
150
                                        P.HDR_OLDEST_ACTIVE = header->hdr_oldest_active;
 
151
                                        P.HDR_NEXT_TRANS = header->hdr_next_transaction;
 
152
                                        P.SEQUENCE = header->hdr_sequence;
 
153
                                        P.HDR_FLAGS = header->hdr_flags;
 
154
                                        temp.gds_quad_high = header->hdr_creation_date[0];
 
155
                                        temp.gds_quad_low = header->hdr_creation_date[1];
 
156
                                        P.HDR_CREATION_DATE = temp;
 
157
                                        P.HDR_ATTACHMENT_ID = header->hdr_attachment_id;
 
158
                                        P.HDR_IMPLEMENTATION = header->hdr_implementation;
 
159
                                        P.HDR_SHADOW_COUNT = header->hdr_shadow_count;
 
160
                                        break;
 
161
 
 
162
                                case pag_pages:
 
163
                                        pip = (page_inv_page*) page;
 
164
                                        P.PIP_MIN.NULL = FALSE;
 
165
                                        P.PIP_MIN = pip->pip_min;
 
166
                                        break;
 
167
 
 
168
                                case pag_transactions:
 
169
                                        P.TIP_NEXT.NULL = FALSE;
 
170
                                        P.TIP_NEXT = ((tx_inv_page*) page)->tip_next;
 
171
                                        break;
 
172
 
 
173
                                case pag_pointer:
 
174
                                        pointer = (PPG) page;
 
175
                                        P.PPG_NEXT.NULL = FALSE;
 
176
                                        P.PPG_COUNT.NULL = FALSE;
 
177
                                        P.PPG_MIN_SPACE.NULL = FALSE;
 
178
                                        P.PPG_MAX_SPACE.NULL = FALSE;
 
179
                                        P.RELATION.NULL = FALSE;
 
180
                                        P.SEQUENCE.NULL = FALSE;
 
181
                                        P.SEQUENCE = pointer->ppg_sequence;
 
182
                                        P.PPG_NEXT = pointer->ppg_next;
 
183
                                        P.RELATION = pointer->ppg_relation;
 
184
                                        P.PPG_COUNT = pointer->ppg_count;
 
185
                                        P.PPG_MIN_SPACE = pointer->ppg_min_space;
 
186
                                        P.PPG_MAX_SPACE = pointer->ppg_max_space;
 
187
                                        break;
 
188
 
 
189
                                case pag_data:
 
190
                                        data = (DPG) page;
 
191
                                        P.DPG_COUNT.NULL = FALSE;
 
192
                                        P.RELATION.NULL = FALSE;
 
193
                                        P.SEQUENCE.NULL = FALSE;
 
194
                                        P.SEQUENCE = data->dpg_sequence;
 
195
                                        P.RELATION = data->dpg_relation;
 
196
                                        P.DPG_COUNT = data->dpg_count;
 
197
                                        break;
 
198
 
 
199
                                case pag_root:
 
200
                                        index_root = (IRT) page;
 
201
                                        P.IRT_COUNT.NULL = FALSE;
 
202
                                        P.RELATION.NULL = FALSE;
 
203
                                        P.IRT_COUNT = index_root->irt_count;
 
204
                                        P.RELATION = index_root->irt_relation;
 
205
                                        break;
 
206
 
 
207
                                case pag_index:
 
208
                                        bucket = (BTR) page;
 
209
                                        P.BTR_SIBLING.NULL = FALSE;
 
210
                                        P.BTR_LENGTH.NULL = FALSE;
 
211
                                        P.BTR_ID.NULL = FALSE;
 
212
                                        P.BTR_LEVEL.NULL = FALSE;
 
213
                                        P.RELATION.NULL = FALSE;
 
214
                                        P.BTR_SIBLING = bucket->btr_sibling;
 
215
                                        P.RELATION = bucket->btr_relation;
 
216
                                        P.BTR_LENGTH = bucket->btr_length;
 
217
                                        P.BTR_ID = bucket->btr_id;
 
218
                                        P.BTR_LEVEL = bucket->btr_level;
 
219
                                        break;
 
220
 
 
221
                                case pag_blob:
 
222
                                        blob = (BLP) page;
 
223
                                        P.BLP_LEAD_PAGE.NULL = FALSE;
 
224
                                        P.BLP_LENGTH.NULL = FALSE;
 
225
                                        P.SEQUENCE.NULL = FALSE;
 
226
                                        P.BLP_LEAD_PAGE = blob->blp_lead_page;
 
227
                                        P.SEQUENCE = blob->blp_sequence;
 
228
                                        P.BLP_LENGTH = blob->blp_length;
 
229
                                        break;
 
230
 
 
231
                                case pag_ids:
 
232
                                default:
 
233
                                        break;
 
234
                                }
 
235
                        }
 
236
                END_STORE
 
237
                ON_ERROR
 
238
                        isc_print_status(gds__status);
 
239
                        printf("can't store into the documentaton database\n");
 
240
                        FINISH;
 
241
                        return;
 
242
                END_ERROR;
 
243
                page_number++;
 
244
        }
 
245
}
 
246