Beispiel #1
0
        public void validate(SqlConnection conn)
        {
            if (total_items >= 0)
            {
                return; // Index already loaded
            }
            lock (_sync_object)
            {
                if (total_items >= 0)
                {
                    return; // Index already loaded
                }
                int?ret = BingoSqlUtils.ExecIntQuery(conn, "select max(id) from {0}",
                                                     _index_data.storageTable);
                if (ret.HasValue)
                {
                    while (_blocks.Count <= ret.Value)
                    {
                        _blocks.Add(null);
                    }
                }

                int?sum = BingoSqlUtils.ExecIntQuery(conn, "select sum(count) from {0}",
                                                     _index_data.storageTable);
                if (!sum.HasValue)
                {
                    total_items = 0;
                }
                else
                {
                    total_items = sum.Value;
                }
            }
        }
Beispiel #2
0
        public void init(SqlConnection conn)
        {
            // Check if blocks have already been loaded
            if (_all_blocks.Count != 0)
            {
                return;
            }

            lock (_sync_object)
            {
                // Check again
                if (_all_blocks.Count != 0)
                {
                    return;
                }

                int?max_part = BingoSqlUtils.ExecIntQuery(conn,
                                                          "SELECT MAX(part) from {0}", _index_data.fingerprintsTable);
                if (!max_part.HasValue)
                {
                    return;
                }

                using (SqlCommand command =
                           new SqlCommand("SELECT [part], [used], [counters], [mapping] from " +
                                          _index_data.fingerprintsTable + " ORDER BY [part]", conn))
                {
                    command.CommandTimeout = 3600;
                    using (SqlDataReader reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            Block new_block = new Block(false, _fp_bytes);
                            new_block.part = Convert.ToInt32(reader[0]);
                            int used = Convert.ToInt32(reader[1]);

                            byte[] counters = (byte[])reader[2];
                            byte[] mapping  = (byte[])reader[3];

                            // Copy mapping
                            int[] data = new int[used];
                            Buffer.BlockCopy(mapping, 0, data, 0, mapping.Length);
                            new_block.indices.AddRange(data);
                            new_block.validateMinMax();

                            // Copy counters
                            Buffer.BlockCopy(counters, 0, new_block.counters, 0, counters.Length);

                            _all_blocks.Add(new_block);
                        }
                    }
                }
            }
        }
Beispiel #3
0
 public int?getStorageIdById(SqlConnection conn, int id)
 {
     return(BingoSqlUtils.ExecIntQuery(conn, "SELECT storage_id from {0} where id={1}",
                                       shadowTable, id));
 }
Beispiel #4
0
        private void _flushBlock(Block block, SqlConnection conn)
        {
            BingoTimer timer = new BingoTimer("fingerprints.flush");

            if (block.part == -1)
            {
                // Add new block
                int?max_id = BingoSqlUtils.ExecIntQuery(conn,
                                                        "SELECT MAX(part) from {0}", _index_data.fingerprintsTable);
                if (max_id == null)
                {
                    max_id = 0;
                }

                block.part = max_id.Value + 1;

                BingoSqlUtils.ExecNonQuery(conn, "INSERT INTO {0} values ({1}, 0, null, null)",
                                           _index_data.fingerprintsTable, block.part);
            }

            BingoLog.logMessage("Flushing fingerprints block {0}...", block.part);

            // Update used column and counters column
            string update_command_text = String.Format(@"UPDATE {0} SET used = @used, 
                              counters = @counters, mapping = @mapping
                              where part = {1}", _index_data.fingerprintsTable, block.part);

            using (SqlCommand command = new SqlCommand(update_command_text, conn))
            {
                command.CommandTimeout = 3600;
                command.Parameters.AddWithValue("@used", block.indices.Count);

                byte[] countes_bytes = new byte[8 * _fp_bytes * sizeof(int)];
                Buffer.BlockCopy(block.counters, 0, countes_bytes, 0, countes_bytes.Length);

                SqlBinary countes = new SqlBinary(countes_bytes);
                command.Parameters.AddWithValue("@counters", countes);

                byte[] mapping_bytes = new byte[block.indices.Count * sizeof(int)];
                Buffer.BlockCopy(block.indices.ToArray(), 0, mapping_bytes, 0, mapping_bytes.Length);

                SqlBinary mapping = new SqlBinary(mapping_bytes);
                command.Parameters.AddWithValue("@mapping", mapping);

                command.ExecuteNonQuery();
            }

            // Update bit chunks
            BingoSqlUtils.ExecNonQuery(conn, "DELETE FROM {0} WHERE part = {1}",
                                       _index_data.fingerprintBitsTable, block.part);

            string update_bits_text = String.Format(@"INSERT INTO {0} VALUES ({1}, @bit, @bit_chunk)",
                                                    _index_data.fingerprintBitsTable, block.part);

            using (SqlCommand command = new SqlCommand(update_bits_text, conn))
            {
                command.CommandTimeout = 3600;
                command.Parameters.Add("@bit", SqlDbType.Int);
                command.Parameters.Add("@bit_chunk", SqlDbType.Binary);

                byte[] chunk = new byte[_chunk_bytes];

                for (int i = 0; i < 8 * _fp_bytes; i++)
                {
                    command.Parameters["@bit"].Value = i;

                    Buffer.BlockCopy(block.bits[i], 0, chunk, 0, chunk.Length);

                    SqlBinary sql_chunk = new SqlBinary(chunk);
                    command.Parameters["@bit_chunk"].Value = sql_chunk;

                    command.ExecuteNonQuery();
                }
            }

            block.pending = false;
            block.bits    = null;
            block.indices = null;

            BingoLog.logMessage("  Done.");
            timer.end();
        }