minutes_11-27-07: all_seminaive.pl

File all_seminaive.pl, 11.6 KB (added by mar, 11 years ago)
Line 
1CREATE OR REPLACE FUNCTION all_snaive_pl() RETURNS integer as $$
2{
3    my $n_rows = 0;
4
5    my $rdfStmtTable1 = 'jena_g1t1_stmt';
6    my $rdfStmtTable2 = 'jena_g2t1_stmt';
7    my $bothRdfStmtTables = 'jena_gALL_stmt';
8    my $allPropertiesTable = 'all_properties';
9    my $propertyTable = 'per_loop_properties';
10
11#      # Create an rdf table with both rdf files
12#      {
13#       # Create the new table
14#       $all_rv = spi_exec_query('CREATE TABLE ' . $bothRdfStmtTables . ' (subj VARCHAR(250) NOT NULL, prop VARCHAR(250) NOT NULL, obj VARCHAR(250) NOT NULL, graphid INTEGER)');
15#       if( $all_rv->{status} ne SPI_OK_UTILITY) {
16#           elog(NOTICE,
17#                'ERROR(CREATE ' . $bothRdfStmtTables . '): Status not SPI_OK_UTILITY, but ' .
18#                $all_rv->{status});
19#       }
20#       elog(NOTICE, 'NOTE: created ' . $bothRdfStmtTables);
21
22#       # Insert both existing tables
23#       $all_rv = spi_exec_query('
24#       INSERT INTO ' . $bothRdfStmtTables . '
25#               (SELECT * from ' . $rdfStmtTable1 . ' )
26#                  UNION
27#                  (SELECT * from ' . $rdfStmtTable2 . ' )');
28
29#       if( $all_rv->{status} ne SPI_OK_INSERT) {
30#           elog(NOTICE,
31#                'ERROR(INSERT): Status not SPI_OK_INSERT, but ' .
32#                $all_rv->{status});
33#       }
34#       elog(NOTICE, 'NOTE: inserted both tables into ' . $bothRdfStmtTables);
35#      }
36
37    # Create a table with all properties from RDF graph
38    {
39        # Create the new table
40        my $rv = spi_exec_query('CREATE TABLE ' . $allPropertiesTable . ' (prop VARCHAR(250) NOT NULL)');
41        if( $rv->{status} ne SPI_OK_UTILITY) {
42            elog(NOTICE,
43                 'ERROR(CREATE ' . $allPropertiesTable . '): Status not SPI_OK_UTILITY, but ' .
44                 $rv->{status});
45        }
46       
47        $rv = spi_exec_query('INSERT INTO ' . $allPropertiesTable .
48                             ' SELECT DISTINCT prop FROM ' . $bothRdfStmtTables);
49        if( $rv->{status} ne SPI_OK_SELECT) {
50            elog(NOTICE, 'ERROR: Status not SPI_OK_SELECT, but ' . $rv->{status});
51        }
52    }
53
54    # Create a table for properties for use in our per-loop queries
55    {
56        # Create the new table
57        my $rv = spi_exec_query('CREATE TABLE ' . $propertyTable . ' (prop VARCHAR(250) NOT NULL)');
58        if( $rv->{status} ne SPI_OK_UTILITY) {
59            elog(NOTICE,
60                 'ERROR(CREATE ' . $propertyTable . '): Status not SPI_OK_UTILITY, but ' .
61                 $rv->{status});
62        }
63    }
64
65    ##############################################################################
66    # Perform the transitive closure for each of the properties in the RDF graph
67    ##############################################################################
68    {
69        my $all_rv = spi_exec_query('SELECT prop FROM ' . $allPropertiesTable);
70        if( $all_rv->{status} ne SPI_OK_SELECT) {
71            elog(NOTICE, 'ERROR: Status not SPI_OK_SELECT, but ' . $all_rv->{status});
72        }
73
74        # Loop through the prop results, creating a new namespace as you go
75        for( my $i = 0; $i < scalar(@{$all_rv->{rows}}); $i++ ) {
76            my $prop = $all_rv->{rows}[$i]->{prop};
77
78            if( $prop =~ m/([^\#]+)\#(.*)/ ) {
79                my $prefix = $1;
80                my $id = $2;
81
82                my $newProperty = 'http://localhost/dtc#' . $id;
83                elog(NOTICE, 'NOTE: PREFIX: ' . $prefix . ' ID: ' . $id . ' NEW: ' . $newProperty);
84
85                # Insert the existing property into a table so that we can
86                # start our processing
87                {
88                    # Delete existing entries
89                    my $rv = spi_exec_query('DELETE FROM ' . $propertyTable);
90                    if( $rv->{status} ne SPI_OK_DELETE) {
91                        elog(NOTICE, 'ERROR(DELETE ' . $propertyTable .
92                             '): Status not SPI_OK_DELETE, but ' .
93                             $rv->{status});
94                    }
95
96                    # Insert the new properties into our table
97                    $rv = spi_exec_query('INSERT INTO ' . $propertyTable .
98                                         ' values(\'' . $prop . '\')');
99                    if( $rv->{status} ne SPI_OK_INSERT) {
100                        elog(NOTICE, 'ERROR(INSERT ' . $propertyTable .
101                             '): Status not SPI_OK_INSERT, but ' .
102                             $rv->{status});
103                    }
104                }
105               
106
107                ################################################################
108                # INNER PER-PROPERTY LOOP
109                ################################################################
110                my $deltaPTable = 'delta_p';
111                my $deltaPTableTmp = 'delta_p_tmp';
112                my $deltaQTable = 'delta_q';
113                my $pTable = 'p_' . $id;
114   
115                # Create the necessary tables for our execution
116                {
117                    my $rv = spi_exec_query('CREATE TABLE ' . $pTable . ' (subj VARCHAR(250) NOT NULL, prop VARCHAR(250) NOT NULL, obj VARCHAR(250) NOT NULL)');
118                    if( $rv->{status} ne SPI_OK_UTILITY) {
119                        elog(NOTICE,
120                             'ERROR(CREATE ' . $pTable . '): Status not SPI_OK_UTILITY, but ' .
121                             $rv->{status});
122                    }
123                    elog(NOTICE, 'NOTE: created ' . $pTable);
124
125                    $rv = spi_exec_query('CREATE TABLE ' . $deltaPTable . ' (subj VARCHAR(250) NOT NULL, prop VARCHAR(250) NOT NULL, obj VARCHAR(250) NOT NULL)');
126                    if( $rv->{status} ne SPI_OK_UTILITY) {
127                        elog(NOTICE,
128                             'ERROR(CREATE ' . $deltaPTable . ' ): Status not SPI_OK_UTILITY, but ' .
129                             $rv->{status});
130                    }
131                    elog(NOTICE, 'NOTE: created ' . $deltaPTable);
132
133                    $rv = spi_exec_query('CREATE TABLE ' . $deltaQTable . ' (subj VARCHAR(250) NOT NULL, prop VARCHAR(250) NOT NULL, obj VARCHAR(250) NOT NULL)');
134                    if( $rv->{status} ne SPI_OK_UTILITY) {
135                        elog(NOTICE,
136                             'ERROR(CREATE ' . $deltaQTable . '): Status not SPI_OK_UTILITY, but ' .
137                             $rv->{status});
138                    }
139                    elog(NOTICE, 'NOTE: created ' . $deltaQTable);
140
141                    $rv = spi_exec_query('CREATE TABLE ' . $deltaPTableTmp . ' (subj VARCHAR(250) NOT NULL, prop VARCHAR(250) NOT NULL, obj VARCHAR(250) NOT NULL)');
142                    if( $rv->{status} ne SPI_OK_UTILITY) {
143                        elog(NOTICE,
144                             'ERROR(CREATE ' . $deltaPTableTmp . '): Status not SPI_OK_UTILITY, but ' .
145                             $rv->{status});
146                    }
147                    elog(NOTICE, 'NOTE: created ' . $deltaPTableTmp);
148                }       
149
150                # Put the initial values into p
151                {
152                    my $rv = spi_exec_query('INSERT INTO ' . $pTable . ' (SELECT DISTINCT x.subj, x.prop, x.obj FROM ' . $bothRdfStmtTables . ' x, ' . $propertyTable . ' y WHERE (x.prop = y.prop))');
153                   
154                    if( $rv->{status} ne SPI_OK_INSERT) {
155                        elog(NOTICE,
156                             'ERROR(INSERT): Status not SPI_OK_INSERT, but ' .
157                             $rv->{status});
158                    }
159                    elog(NOTICE, 'NOTE: created non-reflexive seed table');
160                }
161
162                # Set delta_p to the initial values of p
163                {
164                    my $rv = spi_exec_query('INSERT INTO ' . $deltaPTable . ' (SELECT * FROM ' . $pTable . ')');
165                    if( $rv->{status} ne SPI_OK_INSERT) {
166                        elog(NOTICE,
167                             'ERROR(INSERT): Status not SPI_OK_INSERT, but ' .
168                             $rv->{status});
169                    }
170                    elog(NOTICE, 'NOTE: inserted initial ' . $pTable . ' into ' . $deltaPTable);
171                }
172
173                # Determine the number of lines in this iteration's calculation
174                {
175                    my $rv = spi_exec_query('SELECT COUNT(*) FROM ' . $deltaPTable);
176                   
177                    if( $rv->{status} ne SPI_OK_SELECT) {
178                        elog(NOTICE, 'ERROR: Status not SPI_OK_SELECT, but ' . $rv->{status});
179                    }
180                    $n_rows = $rv->{rows}[0]->{count};
181                    elog(NOTICE, 'NOTE: n_rows ' . $n_rows);
182                }
183               
184                while( $n_rows > 0 ) {
185
186                    # Delete from delta_q
187                    {
188                        my $rv = spi_exec_query('DELETE FROM ' . $deltaQTable);
189                        if( $rv->{status} ne SPI_OK_DELETE) {
190                            elog(NOTICE,
191                                 'ERROR(DELETE ' . $deltaQTable . '): Status not SPI_OK_DELETE, but ' .
192                                 $rv->{status});
193                        }
194                        elog(NOTICE, 'NOTE: deleted ' . $deltaQTable);
195                    }   
196                   
197                    # Insert the results of the previous calculation into delta_q
198                    {
199                        my $rv = spi_exec_query('INSERT INTO ' . $deltaQTable . ' (SELECT * FROM ' . $deltaPTable . ' )');
200                        if( $rv->{status} ne SPI_OK_INSERT) {
201                            elog(NOTICE,
202                                 'ERROR(INSERT): Status not SPI_OK_INSERT, but ' .
203                                 $rv->{status});
204                        }
205                        elog(NOTICE, 'NOTE: inserted ' . $deltaPTable . ' into ' . $deltaQTable);
206                    }
207
208                    # Delete from delta_p
209                    {
210                        my $rv = spi_exec_query('DELETE FROM ' . $deltaPTable);
211                        if( $rv->{status} ne SPI_OK_DELETE) {
212                            elog(NOTICE,
213                                 'ERROR(DELETE ' . $deltaQTable . '): Status not SPI_OK_DELETE, but ' .
214                                 $rv->{status});
215                        }
216                        elog(NOTICE, 'NOTE: deleted ' . $deltaQTable);
217                    }   
218
219                    # Calculate the next iteration
220                    {
221                        my $rv = spi_exec_query('INSERT INTO ' . $deltaPTableTmp . ' (SELECT DISTINCT x.subj, x.prop, y.obj FROM ' . $pTable . ' x, ' . $deltaQTable . ' y WHERE (x.obj = y.subj))');
222
223                        if( $rv->{status} ne SPI_OK_INSERT) {
224                            elog(NOTICE,
225                                 'ERROR(INSERT): Status not SPI_OK_INSERT, but ' .
226                                 $rv->{status});
227                        }
228                        elog(NOTICE, 'NOTE: calculating ' . $deltaPTableTmp);
229
230                        $rv = spi_exec_query('SELECT COUNT(*) FROM ' . $deltaPTableTmp);
231                       
232                        if( $rv->{status} ne SPI_OK_SELECT) {
233                            elog(NOTICE, 'ERROR: Status not SPI_OK_SELECT, but ' . $rv->{status});
234                        }
235                        $n_rows = $rv->{rows}[0]->{count};
236                        elog(NOTICE, 'NOTE: n_rows ' . $deltaPTableTmp . ' ' . $n_rows);
237
238                        # --------------------------------------
239
240
241                        $rv = spi_exec_query('INSERT INTO ' . $deltaPTable . ' (SELECT * FROM ' . $deltaPTableTmp . ' EXCEPT SELECT * from ' . $pTable . ')');
242
243                        if( $rv->{status} ne SPI_OK_INSERT) {
244                            elog(NOTICE,
245                                 'ERROR(INSERT): Status not SPI_OK_INSERT, but ' .
246                                 $rv->{status});
247                        }
248                        elog(NOTICE, 'NOTE: calculating ' . $deltaPTable);
249
250                        $rv = spi_exec_query('SELECT COUNT(*) FROM ' . $deltaPTable);
251                       
252                        if( $rv->{status} ne SPI_OK_SELECT) {
253                            elog(NOTICE, 'ERROR: Status not SPI_OK_SELECT, but ' . $rv->{status});
254                        }
255                        $n_rows = $rv->{rows}[0]->{count};
256                        elog(NOTICE, 'NOTE: n_rows ' . $deltaPTable . ' ' . $n_rows);
257
258                    }
259
260                    # Determine the number of lines in this iteration's calculation
261                    {
262                        my $rv = spi_exec_query('SELECT COUNT(*) FROM ' . $deltaPTable);
263                       
264                        if( $rv->{status} ne SPI_OK_SELECT) {
265                            elog(NOTICE, 'ERROR: Status not SPI_OK_SELECT, but ' . $rv->{status});
266                        }
267                        $n_rows = $rv->{rows}[0]->{count};
268                        elog(NOTICE, 'NOTE: n_rows ' . $n_rows);
269                    }
270
271                    # Insert our results into the answer p
272                    {
273                        my $rv = spi_exec_query('INSERT INTO ' . $pTable . ' (SELECT * FROM ' . $deltaPTable . ')');
274                        if( $rv->{status} ne SPI_OK_INSERT) {
275                            elog(NOTICE,
276                                 'ERROR(INSERT): Status not SPI_OK_INSERT, but ' .
277                                 $rv->{status});
278                        }
279                        elog(NOTICE, 'NOTE: inserting ' . $deltaPTable . ' into ' . $pTable);
280                    }
281
282                }
283               
284                # Clean up by removing the delta tables now that we are done.
285                {
286                    my $rv = spi_exec_query('DROP TABLE ' . $deltaPTable);
287                    if( $rv->{status} ne SPI_OK_UTILITY) {
288                        elog(NOTICE,
289                             'ERROR(DROP ' . $deltaPTable . '): Status not SPI_OK_UTILITY, but ' .
290                             $rv->{status});
291                    }
292                    elog(NOTICE, 'NOTE: dropped table ' . $deltaPTable);
293
294                    my $rv = spi_exec_query('DROP TABLE ' . $deltaQTable);
295                    if( $rv->{status} ne SPI_OK_UTILITY) {
296                        elog(NOTICE,
297                             'ERROR(DROP ' . $deltaQTable . '): Status not SPI_OK_UTILITY, but ' .
298                             $rv->{status});
299                    }
300                    elog(NOTICE, 'NOTE: dropped table ' . $deltaQTable);
301
302                    my $rv = spi_exec_query('DROP TABLE ' . $deltaPTableTmp);
303                    if( $rv->{status} ne SPI_OK_UTILITY) {
304                        elog(NOTICE,
305                             'ERROR(DROP ' . $deltaPTableTmp . '): Status not SPI_OK_UTILITY, but ' .
306                             $rv->{status});
307                    }
308                    elog(NOTICE, 'NOTE: dropped table ' . $deltaPTableTmp);
309                }
310
311                # Determine the number of lines in the answer
312                {
313                    my $rv = spi_exec_query('SELECT COUNT(*) FROM ' . $pTable);
314                   
315                    if( $rv->{status} ne SPI_OK_SELECT) {
316                        elog(NOTICE, 'ERROR: Status not SPI_OK_SELECT, but ' . $rv->{status});
317                    }
318                    $n_rows = $rv->{rows}[0]->{count};
319                    elog(NOTICE, 'NOTE: n_rows ' . $n_rows);
320                }
321
322            }
323        }
324    }
325
326    # Clean up by removing the property table now that we are done.
327    {
328        my $rv = spi_exec_query('DROP TABLE ' . $propertyTable);
329        if( $rv->{status} ne SPI_OK_UTILITY) {
330            elog(NOTICE,
331                 'ERROR(DROP ' . $propertyTable . '): Status not SPI_OK_UTILITY, but ' .
332                 $rv->{status});
333        }
334        elog(NOTICE, 'NOTE: dropped table ' . $propertyTable);
335    }
336
337    return $n_rows;
338}
339$$ LANGUAGE plperl;