No OneTemporary
Actions

Size

32 KB

Subscribers

None

View Options

	diff --git a/src/leveldb/Makefile b/src/leveldb/Makefile
	index fdc66f9a2..fef085b9c 100644
	--- a/src/leveldb/Makefile
	+++ b/src/leveldb/Makefile
	@@ -1,199 +1,202 @@
	# Copyright (c) 2011 The LevelDB Authors. All rights reserved.
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file. See the AUTHORS file for names of contributors.

	#-----------------------------------------------
	# Uncomment exactly one of the lines labelled (A), (B), and (C) below
	# to switch between compilation modes.

	OPT ?= -O2 -DNDEBUG # (A) Production use (optimized mode)
	# OPT ?= -g2 # (B) Debug mode, w/ full line-level debugging symbols
	# OPT ?= -O2 -g2 -DNDEBUG # (C) Profiling mode: opt, but w/debugging symbols
	#-----------------------------------------------

	# detect what platform we're building on
	$(shell CC=$(CC) CXX=$(CXX) TARGET_OS=$(TARGET_OS) \
	./build_detect_platform build_config.mk ./)
	# this file is generated by the previous line to set build flags and sources
	include build_config.mk

	CFLAGS += -I. -I./include $(PLATFORM_CCFLAGS) $(OPT)
	CXXFLAGS += -I. -I./include $(PLATFORM_CXXFLAGS) $(OPT)

	LDFLAGS += $(PLATFORM_LDFLAGS)
	LIBS += $(PLATFORM_LIBS)

	LIBOBJECTS = $(SOURCES:.cc=.o)
	MEMENVOBJECTS = $(MEMENV_SOURCES:.cc=.o)

	TESTUTIL = ./util/testutil.o
	TESTHARNESS = ./util/testharness.o $(TESTUTIL)

	TESTS = \
	arena_test \
	bloom_test \
	c_test \
	cache_test \
	coding_test \
	corruption_test \
	crc32c_test \
	db_test \
	dbformat_test \
	env_test \
	filename_test \
	filter_block_test \
	log_test \
	memenv_test \
	skiplist_test \
	table_test \
	version_edit_test \
	version_set_test \
	write_batch_test

	-PROGRAMS = db_bench $(TESTS)
	+PROGRAMS = db_bench leveldbutil $(TESTS)
	BENCHMARKS = db_bench_sqlite3 db_bench_tree_db

	LIBRARY = libleveldb.a
	MEMENVLIBRARY = libmemenv.a

	default: all

	# Should we build shared libraries?
	ifneq ($(PLATFORM_SHARED_EXT),)

	ifneq ($(PLATFORM_SHARED_VERSIONED),true)
	SHARED1 = libleveldb.$(PLATFORM_SHARED_EXT)
	SHARED2 = $(SHARED1)
	SHARED3 = $(SHARED1)
	SHARED = $(SHARED1)
	else
	# Update db.h if you change these.
	SHARED_MAJOR = 1
	-SHARED_MINOR = 7
	+SHARED_MINOR = 8
	SHARED1 = libleveldb.$(PLATFORM_SHARED_EXT)
	SHARED2 = $(SHARED1).$(SHARED_MAJOR)
	SHARED3 = $(SHARED1).$(SHARED_MAJOR).$(SHARED_MINOR)
	SHARED = $(SHARED1) $(SHARED2) $(SHARED3)
	$(SHARED1): $(SHARED3)
	ln -fs $(SHARED3) $(SHARED1)
	$(SHARED2): $(SHARED3)
	ln -fs $(SHARED3) $(SHARED2)
	endif

	$(SHARED3):
	$(CXX) $(LDFLAGS) $(PLATFORM_SHARED_LDFLAGS)$(SHARED2) $(CXXFLAGS) $(PLATFORM_SHARED_CFLAGS) $(SOURCES) -o $(SHARED3) $(LIBS)

	endif # PLATFORM_SHARED_EXT

	all: $(SHARED) $(LIBRARY)

	check: all $(PROGRAMS) $(TESTS)
	for t in $(TESTS); do echo "***** Running $$t"; ./$$t \|\| exit 1; done

	clean:
	-rm -f $(PROGRAMS) $(BENCHMARKS) $(LIBRARY) $(SHARED) $(MEMENVLIBRARY) /.o //.o ios-x86//.o ios-arm//*.o build_config.mk
	-rm -rf ios-x86/* ios-arm/*

	$(LIBRARY): $(LIBOBJECTS)
	rm -f $@
	$(AR) -rs $@ $(LIBOBJECTS)

	db_bench: db/db_bench.o $(LIBOBJECTS) $(TESTUTIL)
	$(CXX) $(LDFLAGS) db/db_bench.o $(LIBOBJECTS) $(TESTUTIL) -o $@ $(LIBS)

	db_bench_sqlite3: doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL)
	$(CXX) $(LDFLAGS) doc/bench/db_bench_sqlite3.o $(LIBOBJECTS) $(TESTUTIL) -o $@ -lsqlite3 $(LIBS)

	db_bench_tree_db: doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL)
	$(CXX) $(LDFLAGS) doc/bench/db_bench_tree_db.o $(LIBOBJECTS) $(TESTUTIL) -o $@ -lkyotocabinet $(LIBS)

	+leveldbutil: db/leveldb_main.o $(LIBOBJECTS)
	+ $(CXX) $(LDFLAGS) db/leveldb_main.o $(LIBOBJECTS) -o $@ $(LIBS)
	+
	arena_test: util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) util/arena_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	bloom_test: util/bloom_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) util/bloom_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	c_test: db/c_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/c_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	cache_test: util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) util/cache_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	coding_test: util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) util/coding_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	corruption_test: db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/corruption_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	crc32c_test: util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) util/crc32c_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	db_test: db/db_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/db_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	dbformat_test: db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	env_test: util/env_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) util/env_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	filename_test: db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/filename_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	filter_block_test: table/filter_block_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) table/filter_block_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	log_test: db/log_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/log_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	table_test: table/table_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) table/table_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	skiplist_test: db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/skiplist_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	version_edit_test: db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/version_edit_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	version_set_test: db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/version_set_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	write_batch_test: db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) db/write_batch_test.o $(LIBOBJECTS) $(TESTHARNESS) -o $@ $(LIBS)

	$(MEMENVLIBRARY) : $(MEMENVOBJECTS)
	rm -f $@
	$(AR) -rs $@ $(MEMENVOBJECTS)

	memenv_test : helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS)
	$(CXX) $(LDFLAGS) helpers/memenv/memenv_test.o $(MEMENVLIBRARY) $(LIBRARY) $(TESTHARNESS) -o $@ $(LIBS)

	ifeq ($(PLATFORM), IOS)
	# For iOS, create universal object files to be used on both the simulator and
	# a device.
	PLATFORMSROOT=/Applications/Xcode.app/Contents/Developer/Platforms
	SIMULATORROOT=$(PLATFORMSROOT)/iPhoneSimulator.platform/Developer
	DEVICEROOT=$(PLATFORMSROOT)/iPhoneOS.platform/Developer
	IOSVERSION=$(shell defaults read $(PLATFORMSROOT)/iPhoneOS.platform/version CFBundleShortVersionString)

	.cc.o:
	mkdir -p ios-x86/$(dir $@)
	$(CXX) $(CXXFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 -c $< -o ios-x86/$@
	mkdir -p ios-arm/$(dir $@)
	$(DEVICEROOT)/usr/bin/$(CXX) $(CXXFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 -c $< -o ios-arm/$@
	lipo ios-x86/$@ ios-arm/$@ -create -output $@

	.c.o:
	mkdir -p ios-x86/$(dir $@)
	$(CC) $(CFLAGS) -isysroot $(SIMULATORROOT)/SDKs/iPhoneSimulator$(IOSVERSION).sdk -arch i686 -c $< -o ios-x86/$@
	mkdir -p ios-arm/$(dir $@)
	$(DEVICEROOT)/usr/bin/$(CC) $(CFLAGS) -isysroot $(DEVICEROOT)/SDKs/iPhoneOS$(IOSVERSION).sdk -arch armv6 -arch armv7 -c $< -o ios-arm/$@
	lipo ios-x86/$@ ios-arm/$@ -create -output $@

	else
	.cc.o:
	$(CXX) $(CXXFLAGS) -c $< -o $@

	.c.o:
	$(CC) $(CFLAGS) -c $< -o $@
	endif
	diff --git a/src/leveldb/build_detect_platform b/src/leveldb/build_detect_platform
	index 1080df77f..609cb5122 100755
	--- a/src/leveldb/build_detect_platform
	+++ b/src/leveldb/build_detect_platform
	@@ -1,199 +1,200 @@
	#!/bin/sh
	#
	# Detects OS we're compiling on and outputs a file specified by the first
	# argument, which in turn gets read while processing Makefile.
	#
	# The output will set the following variables:
	# CC C Compiler path
	# CXX C++ Compiler path
	# PLATFORM_LDFLAGS Linker flags
	# PLATFORM_LIBS Libraries flags
	# PLATFORM_SHARED_EXT Extension for shared libraries
	# PLATFORM_SHARED_LDFLAGS Flags for building shared library
	# This flag is embedded just before the name
	# of the shared library without intervening spaces
	# PLATFORM_SHARED_CFLAGS Flags for compiling objects for shared library
	# PLATFORM_CCFLAGS C compiler flags
	# PLATFORM_CXXFLAGS C++ compiler flags. Will contain:
	# PLATFORM_SHARED_VERSIONED Set to 'true' if platform supports versioned
	# shared libraries, empty otherwise.
	#
	# The PLATFORM_CCFLAGS and PLATFORM_CXXFLAGS might include the following:
	#
	# -DLEVELDB_CSTDATOMIC_PRESENT if <cstdatomic> is present
	# -DLEVELDB_PLATFORM_POSIX for Posix-based platforms
	# -DSNAPPY if the Snappy library is present
	#

	OUTPUT=$1
	PREFIX=$2
	if test -z "$OUTPUT" \|\| test -z "$PREFIX"; then
	echo "usage: $0 <output-filename> <directory_prefix>" >&2
	exit 1
	fi

	# Delete existing output, if it exists
	rm -f $OUTPUT
	touch $OUTPUT

	if test -z "$CC"; then
	CC=cc
	fi

	if test -z "$CXX"; then
	CXX=g++
	fi

	# Detect OS
	if test -z "$TARGET_OS"; then
	TARGET_OS=`uname -s`
	fi

	COMMON_FLAGS=
	CROSS_COMPILE=
	PLATFORM_CCFLAGS=
	PLATFORM_CXXFLAGS=
	PLATFORM_LDFLAGS=
	PLATFORM_LIBS=
	PLATFORM_SHARED_EXT="so"
	PLATFORM_SHARED_LDFLAGS="-shared -Wl,-soname -Wl,"
	PLATFORM_SHARED_CFLAGS="-fPIC"
	PLATFORM_SHARED_VERSIONED=true

	MEMCMP_FLAG=
	if [ "$CXX" = "g++" ]; then
	# Use libc's memcmp instead of GCC's memcmp. This results in ~40%
	# performance improvement on readrandom under gcc 4.4.3 on Linux/x86.
	MEMCMP_FLAG="-fno-builtin-memcmp"
	fi

	case "$TARGET_OS" in
	Darwin)
	PLATFORM=OS_MACOSX
	COMMON_FLAGS="$MEMCMP_FLAG -DOS_MACOSX"
	PLATFORM_SHARED_EXT=dylib
	[ -z "$INSTALL_PATH" ] && INSTALL_PATH=`pwd`
	PLATFORM_SHARED_LDFLAGS="-dynamiclib -install_name $INSTALL_PATH/"
	PORT_FILE=port/port_posix.cc
	;;
	Linux)
	PLATFORM=OS_LINUX
	COMMON_FLAGS="$MEMCMP_FLAG -pthread -DOS_LINUX"
	PLATFORM_LDFLAGS="-pthread"
	PORT_FILE=port/port_posix.cc
	;;
	SunOS)
	PLATFORM=OS_SOLARIS
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_SOLARIS"
	PLATFORM_LIBS="-lpthread -lrt"
	PORT_FILE=port/port_posix.cc
	;;
	FreeBSD)
	PLATFORM=OS_FREEBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_FREEBSD"
	PLATFORM_LIBS="-lpthread"
	PORT_FILE=port/port_posix.cc
	;;
	NetBSD)
	PLATFORM=OS_NETBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_NETBSD"
	PLATFORM_LIBS="-lpthread -lgcc_s"
	PORT_FILE=port/port_posix.cc
	;;
	OpenBSD)
	PLATFORM=OS_OPENBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_OPENBSD"
	PLATFORM_LDFLAGS="-pthread"
	PORT_FILE=port/port_posix.cc
	;;
	DragonFly)
	PLATFORM=OS_DRAGONFLYBSD
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_DRAGONFLYBSD"
	PLATFORM_LIBS="-lpthread"
	PORT_FILE=port/port_posix.cc
	;;
	OS_ANDROID_CROSSCOMPILE)
	PLATFORM=OS_ANDROID
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_ANDROID -DLEVELDB_PLATFORM_POSIX"
	PLATFORM_LDFLAGS="" # All pthread features are in the Android C library
	PORT_FILE=port/port_posix.cc
	CROSS_COMPILE=true
	;;
	HP-UX)
	PLATFORM=OS_HPUX
	COMMON_FLAGS="$MEMCMP_FLAG -D_REENTRANT -DOS_HPUX"
	PLATFORM_LDFLAGS="-pthread"
	PORT_FILE=port/port_posix.cc
	# man ld: +h internal_name
	PLATFORM_SHARED_LDFLAGS="-shared -Wl,+h -Wl,"
	;;
	OS_WINDOWS_CROSSCOMPILE \| NATIVE_WINDOWS)
	PLATFORM=OS_WINDOWS
	COMMON_FLAGS="-fno-builtin-memcmp -D_REENTRANT -DOS_WINDOWS -DLEVELDB_PLATFORM_WINDOWS -DWINVER=0x0500 -D__USE_MINGW_ANSI_STDIO=1"
	PLATFORM_SOURCES="util/env_win.cc"
	PLATFORM_LIBS="-lshlwapi"
	PORT_FILE=port/port_win.cc
	CROSS_COMPILE=true
	;;
	*)
	echo "Unknown platform!" >&2
	exit 1
	esac

	# We want to make a list of all cc files within util, db, table, and helpers
	# except for the test and benchmark files. By default, find will output a list
	# of all files matching either rule, so we need to append -print to make the
	# prune take effect.
	DIRS="$PREFIX/db $PREFIX/util $PREFIX/table"

	set -f # temporarily disable globbing so that our patterns aren't expanded
	PRUNE_TEST="-name test.cc -prune"
	PRUNE_BENCH="-name *_bench.cc -prune"
	-PORTABLE_FILES=`find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o -name '*.cc' -print \| sort \| sed "s,^$PREFIX/,," \| tr "\n" " "`
	+PRUNE_TOOL="-name leveldb_main.cc -prune"
	+PORTABLE_FILES=`find $DIRS $PRUNE_TEST -o $PRUNE_BENCH -o $PRUNE_TOOL -o -name '*.cc' -print \| sort \| sed "s,^$PREFIX/,," \| tr "\n" " "`

	set +f # re-enable globbing

	# The sources consist of the portable files, plus the platform-specific port
	# file.
	echo "SOURCES=$PORTABLE_FILES $PORT_FILE" >> $OUTPUT
	echo "MEMENV_SOURCES=helpers/memenv/memenv.cc" >> $OUTPUT

	if [ "$CROSS_COMPILE" = "true" ]; then
	# Cross-compiling; do not try any compilation tests.
	true
	else
	# If -std=c++0x works, use <cstdatomic>. Otherwise use port_posix.h.
	$CXX $CXXFLAGS -std=c++0x -x c++ - -o /dev/null 2>/dev/null <<EOF
	#include <cstdatomic>
	int main() {}
	EOF
	if [ "$?" = 0 ]; then
	COMMON_FLAGS="$COMMON_FLAGS -DLEVELDB_PLATFORM_POSIX -DLEVELDB_CSTDATOMIC_PRESENT"
	PLATFORM_CXXFLAGS="-std=c++0x"
	else
	COMMON_FLAGS="$COMMON_FLAGS -DLEVELDB_PLATFORM_POSIX"
	fi

	# Test whether tcmalloc is available
	$CXX $CXXFLAGS -x c++ - -o /dev/null -ltcmalloc 2>/dev/null <<EOF
	int main() {}
	EOF
	if [ "$?" = 0 ]; then
	PLATFORM_LIBS="$PLATFORM_LIBS -ltcmalloc"
	fi
	fi

	PLATFORM_CCFLAGS="$PLATFORM_CCFLAGS $COMMON_FLAGS"
	PLATFORM_CXXFLAGS="$PLATFORM_CXXFLAGS $COMMON_FLAGS"

	echo "CC=$CC" >> $OUTPUT
	echo "CXX=$CXX" >> $OUTPUT
	echo "PLATFORM=$PLATFORM" >> $OUTPUT
	echo "PLATFORM_LDFLAGS=$PLATFORM_LDFLAGS" >> $OUTPUT
	echo "PLATFORM_LIBS=$PLATFORM_LIBS" >> $OUTPUT
	echo "PLATFORM_CCFLAGS=$PLATFORM_CCFLAGS" >> $OUTPUT
	echo "PLATFORM_CXXFLAGS=$PLATFORM_CXXFLAGS" >> $OUTPUT
	echo "PLATFORM_SHARED_CFLAGS=$PLATFORM_SHARED_CFLAGS" >> $OUTPUT
	echo "PLATFORM_SHARED_EXT=$PLATFORM_SHARED_EXT" >> $OUTPUT
	echo "PLATFORM_SHARED_LDFLAGS=$PLATFORM_SHARED_LDFLAGS" >> $OUTPUT
	echo "PLATFORM_SHARED_VERSIONED=$PLATFORM_SHARED_VERSIONED" >> $OUTPUT
	diff --git a/src/leveldb/db/leveldb_main.cc b/src/leveldb/db/leveldb_main.cc
	new file mode 100644
	index 000000000..995d76107
	--- /dev/null
	+++ b/src/leveldb/db/leveldb_main.cc
	@@ -0,0 +1,238 @@
	+// Copyright (c) 2012 The LevelDB Authors. All rights reserved.
	+// Use of this source code is governed by a BSD-style license that can be
	+// found in the LICENSE file. See the AUTHORS file for names of contributors.
	+
	+#include <stdio.h>
	+#include "db/dbformat.h"
	+#include "db/filename.h"
	+#include "db/log_reader.h"
	+#include "db/version_edit.h"
	+#include "db/write_batch_internal.h"
	+#include "leveldb/env.h"
	+#include "leveldb/iterator.h"
	+#include "leveldb/options.h"
	+#include "leveldb/status.h"
	+#include "leveldb/table.h"
	+#include "leveldb/write_batch.h"
	+#include "util/logging.h"
	+
	+namespace leveldb {
	+
	+namespace {
	+
	+bool GuessType(const std::string& fname, FileType* type) {
	+ size_t pos = fname.rfind('/');
	+ std::string basename;
	+ if (pos == std::string::npos) {
	+ basename = fname;
	+ } else {
	+ basename = std::string(fname.data() + pos + 1, fname.size() - pos - 1);
	+ }
	+ uint64_t ignored;
	+ return ParseFileName(basename, &ignored, type);
	+}
	+
	+// Notified when log reader encounters corruption.
	+class CorruptionReporter : public log::Reader::Reporter {
	+ public:
	+ virtual void Corruption(size_t bytes, const Status& status) {
	+ printf("corruption: %d bytes; %s\n",
	+ static_cast<int>(bytes),
	+ status.ToString().c_str());
	+ }
	+};
	+
	+// Print contents of a log file. (*func)() is called on every record.
	+bool PrintLogContents(Env* env, const std::string& fname,
	+ void (*func)(Slice)) {
	+ SequentialFile* file;
	+ Status s = env->NewSequentialFile(fname, &file);
	+ if (!s.ok()) {
	+ fprintf(stderr, "%s\n", s.ToString().c_str());
	+ return false;
	+ }
	+ CorruptionReporter reporter;
	+ log::Reader reader(file, &reporter, true, 0);
	+ Slice record;
	+ std::string scratch;
	+ while (reader.ReadRecord(&record, &scratch)) {
	+ printf("--- offset %llu; ",
	+ static_cast<unsigned long long>(reader.LastRecordOffset()));
	+ (*func)(record);
	+ }
	+ delete file;
	+ return true;
	+}
	+
	+// Called on every item found in a WriteBatch.
	+class WriteBatchItemPrinter : public WriteBatch::Handler {
	+ public:
	+ uint64_t offset_;
	+ uint64_t sequence_;
	+
	+ virtual void Put(const Slice& key, const Slice& value) {
	+ printf(" put '%s' '%s'\n",
	+ EscapeString(key).c_str(),
	+ EscapeString(value).c_str());
	+ }
	+ virtual void Delete(const Slice& key) {
	+ printf(" del '%s'\n",
	+ EscapeString(key).c_str());
	+ }
	+};
	+
	+
	+// Called on every log record (each one of which is a WriteBatch)
	+// found in a kLogFile.
	+static void WriteBatchPrinter(Slice record) {
	+ if (record.size() < 12) {
	+ printf("log record length %d is too small\n",
	+ static_cast<int>(record.size()));
	+ return;
	+ }
	+ WriteBatch batch;
	+ WriteBatchInternal::SetContents(&batch, record);
	+ printf("sequence %llu\n",
	+ static_cast<unsigned long long>(WriteBatchInternal::Sequence(&batch)));
	+ WriteBatchItemPrinter batch_item_printer;
	+ Status s = batch.Iterate(&batch_item_printer);
	+ if (!s.ok()) {
	+ printf(" error: %s\n", s.ToString().c_str());
	+ }
	+}
	+
	+bool DumpLog(Env* env, const std::string& fname) {
	+ return PrintLogContents(env, fname, WriteBatchPrinter);
	+}
	+
	+// Called on every log record (each one of which is a WriteBatch)
	+// found in a kDescriptorFile.
	+static void VersionEditPrinter(Slice record) {
	+ VersionEdit edit;
	+ Status s = edit.DecodeFrom(record);
	+ if (!s.ok()) {
	+ printf("%s\n", s.ToString().c_str());
	+ return;
	+ }
	+ printf("%s", edit.DebugString().c_str());
	+}
	+
	+bool DumpDescriptor(Env* env, const std::string& fname) {
	+ return PrintLogContents(env, fname, VersionEditPrinter);
	+}
	+
	+bool DumpTable(Env* env, const std::string& fname) {
	+ uint64_t file_size;
	+ RandomAccessFile* file = NULL;
	+ Table* table = NULL;
	+ Status s = env->GetFileSize(fname, &file_size);
	+ if (s.ok()) {
	+ s = env->NewRandomAccessFile(fname, &file);
	+ }
	+ if (s.ok()) {
	+ // We use the default comparator, which may or may not match the
	+ // comparator used in this database. However this should not cause
	+ // problems since we only use Table operations that do not require
	+ // any comparisons. In particular, we do not call Seek or Prev.
	+ s = Table::Open(Options(), file, file_size, &table);
	+ }
	+ if (!s.ok()) {
	+ fprintf(stderr, "%s\n", s.ToString().c_str());
	+ delete table;
	+ delete file;
	+ return false;
	+ }
	+
	+ ReadOptions ro;
	+ ro.fill_cache = false;
	+ Iterator* iter = table->NewIterator(ro);
	+ for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
	+ ParsedInternalKey key;
	+ if (!ParseInternalKey(iter->key(), &key)) {
	+ printf("badkey '%s' => '%s'\n",
	+ EscapeString(iter->key()).c_str(),
	+ EscapeString(iter->value()).c_str());
	+ } else {
	+ char kbuf[20];
	+ const char* type;
	+ if (key.type == kTypeDeletion) {
	+ type = "del";
	+ } else if (key.type == kTypeValue) {
	+ type = "val";
	+ } else {
	+ snprintf(kbuf, sizeof(kbuf), "%d", static_cast<int>(key.type));
	+ type = kbuf;
	+ }
	+ printf("'%s' @ %8llu : %s => '%s'\n",
	+ EscapeString(key.user_key).c_str(),
	+ static_cast<unsigned long long>(key.sequence),
	+ type,
	+ EscapeString(iter->value()).c_str());
	+ }
	+ }
	+ s = iter->status();
	+ if (!s.ok()) {
	+ printf("iterator error: %s\n", s.ToString().c_str());
	+ }
	+
	+ delete iter;
	+ delete table;
	+ delete file;
	+ return true;
	+}
	+
	+bool DumpFile(Env* env, const std::string& fname) {
	+ FileType ftype;
	+ if (!GuessType(fname, &ftype)) {
	+ fprintf(stderr, "%s: unknown file type\n", fname.c_str());
	+ return false;
	+ }
	+ switch (ftype) {
	+ case kLogFile: return DumpLog(env, fname);
	+ case kDescriptorFile: return DumpDescriptor(env, fname);
	+ case kTableFile: return DumpTable(env, fname);
	+
	+ default: {
	+ fprintf(stderr, "%s: not a dump-able file type\n", fname.c_str());
	+ break;
	+ }
	+ }
	+ return false;
	+}
	+
	+bool HandleDumpCommand(Env* env, char** files, int num) {
	+ bool ok = true;
	+ for (int i = 0; i < num; i++) {
	+ ok &= DumpFile(env, files[i]);
	+ }
	+ return ok;
	+}
	+
	+}
	+} // namespace leveldb
	+
	+static void Usage() {
	+ fprintf(
	+ stderr,
	+ "Usage: leveldbutil command...\n"
	+ " dump files... -- dump contents of specified files\n"
	+ );
	+}
	+
	+int main(int argc, char** argv) {
	+ leveldb::Env* env = leveldb::Env::Default();
	+ bool ok = true;
	+ if (argc < 2) {
	+ Usage();
	+ ok = false;
	+ } else {
	+ std::string command = argv[1];
	+ if (command == "dump") {
	+ ok = leveldb::HandleDumpCommand(env, argv+2, argc-2);
	+ } else {
	+ Usage();
	+ ok = false;
	+ }
	+ }
	+ return (ok ? 0 : 1);
	+}
	diff --git a/src/leveldb/include/leveldb/db.h b/src/leveldb/include/leveldb/db.h
	index 79142f5b2..f1e70a01e 100644
	--- a/src/leveldb/include/leveldb/db.h
	+++ b/src/leveldb/include/leveldb/db.h
	@@ -1,161 +1,161 @@
	// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file. See the AUTHORS file for names of contributors.

	#ifndef STORAGE_LEVELDB_INCLUDE_DB_H_
	#define STORAGE_LEVELDB_INCLUDE_DB_H_

	#include <stdint.h>
	#include <stdio.h>
	#include "leveldb/iterator.h"
	#include "leveldb/options.h"

	namespace leveldb {

	// Update Makefile if you change these
	static const int kMajorVersion = 1;
	-static const int kMinorVersion = 7;
	+static const int kMinorVersion = 8;

	struct Options;
	struct ReadOptions;
	struct WriteOptions;
	class WriteBatch;

	// Abstract handle to particular state of a DB.
	// A Snapshot is an immutable object and can therefore be safely
	// accessed from multiple threads without any external synchronization.
	class Snapshot {
	protected:
	virtual ~Snapshot();
	};

	// A range of keys
	struct Range {
	Slice start; // Included in the range
	Slice limit; // Not included in the range

	Range() { }
	Range(const Slice& s, const Slice& l) : start(s), limit(l) { }
	};

	// A DB is a persistent ordered map from keys to values.
	// A DB is safe for concurrent access from multiple threads without
	// any external synchronization.
	class DB {
	public:
	// Open the database with the specified "name".
	// Stores a pointer to a heap-allocated database in *dbptr and returns
	// OK on success.
	// Stores NULL in *dbptr and returns a non-OK status on error.
	// Caller should delete *dbptr when it is no longer needed.
	static Status Open(const Options& options,
	const std::string& name,
	DB** dbptr);

	DB() { }
	virtual ~DB();

	// Set the database entry for "key" to "value". Returns OK on success,
	// and a non-OK status on error.
	// Note: consider setting options.sync = true.
	virtual Status Put(const WriteOptions& options,
	const Slice& key,
	const Slice& value) = 0;

	// Remove the database entry (if any) for "key". Returns OK on
	// success, and a non-OK status on error. It is not an error if "key"
	// did not exist in the database.
	// Note: consider setting options.sync = true.
	virtual Status Delete(const WriteOptions& options, const Slice& key) = 0;

	// Apply the specified updates to the database.
	// Returns OK on success, non-OK on failure.
	// Note: consider setting options.sync = true.
	virtual Status Write(const WriteOptions& options, WriteBatch* updates) = 0;

	// If the database contains an entry for "key" store the
	// corresponding value in *value and return OK.
	//
	// If there is no entry for "key" leave *value unchanged and return
	// a status for which Status::IsNotFound() returns true.
	//
	// May return some other Status on an error.
	virtual Status Get(const ReadOptions& options,
	const Slice& key, std::string* value) = 0;

	// Return a heap-allocated iterator over the contents of the database.
	// The result of NewIterator() is initially invalid (caller must
	// call one of the Seek methods on the iterator before using it).
	//
	// Caller should delete the iterator when it is no longer needed.
	// The returned iterator should be deleted before this db is deleted.
	virtual Iterator* NewIterator(const ReadOptions& options) = 0;

	// Return a handle to the current DB state. Iterators created with
	// this handle will all observe a stable snapshot of the current DB
	// state. The caller must call ReleaseSnapshot(result) when the
	// snapshot is no longer needed.
	virtual const Snapshot* GetSnapshot() = 0;

	// Release a previously acquired snapshot. The caller must not
	// use "snapshot" after this call.
	virtual void ReleaseSnapshot(const Snapshot* snapshot) = 0;

	// DB implementations can export properties about their state
	// via this method. If "property" is a valid property understood by this
	// DB implementation, fills "*value" with its current value and returns
	// true. Otherwise returns false.
	//
	//
	// Valid property names include:
	//
	// "leveldb.num-files-at-level<N>" - return the number of files at level <N>,
	// where <N> is an ASCII representation of a level number (e.g. "0").
	// "leveldb.stats" - returns a multi-line string that describes statistics
	// about the internal operation of the DB.
	// "leveldb.sstables" - returns a multi-line string that describes all
	// of the sstables that make up the db contents.
	virtual bool GetProperty(const Slice& property, std::string* value) = 0;

	// For each i in [0,n-1], store in "sizes[i]", the approximate
	// file system space used by keys in "[range[i].start .. range[i].limit)".
	//
	// Note that the returned sizes measure file system space usage, so
	// if the user data compresses by a factor of ten, the returned
	// sizes will be one-tenth the size of the corresponding user data size.
	//
	// The results may not include the sizes of recently written data.
	virtual void GetApproximateSizes(const Range* range, int n,
	uint64_t* sizes) = 0;

	// Compact the underlying storage for the key range [begin,end].
	// In particular, deleted and overwritten versions are discarded,
	// and the data is rearranged to reduce the cost of operations
	// needed to access the data. This operation should typically only
	// be invoked by users who understand the underlying implementation.
	//
	// begin==NULL is treated as a key before all keys in the database.
	// end==NULL is treated as a key after all keys in the database.
	// Therefore the following call will compact the entire database:
	// db->CompactRange(NULL, NULL);
	virtual void CompactRange(const Slice* begin, const Slice* end) = 0;

	private:
	// No copying allowed
	DB(const DB&);
	void operator=(const DB&);
	};

	// Destroy the contents of the specified database.
	// Be very careful using this method.
	Status DestroyDB(const std::string& name, const Options& options);

	// If a DB cannot be opened, you may attempt to call this method to
	// resurrect as much of the contents of the database as possible.
	// Some data may be lost, so be careful when calling this function
	// on a database that contains important information.
	Status RepairDB(const std::string& dbname, const Options& options);

	} // namespace leveldb

	#endif // STORAGE_LEVELDB_INCLUDE_DB_H_
	diff --git a/src/leveldb/port/port_posix.h b/src/leveldb/port/port_posix.h
	index 6ca352e2c..f2b89bffb 100644
	--- a/src/leveldb/port/port_posix.h
	+++ b/src/leveldb/port/port_posix.h
	@@ -1,151 +1,157 @@
	// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file. See the AUTHORS file for names of contributors.
	//
	// See port_example.h for documentation for the following types/functions.

	#ifndef STORAGE_LEVELDB_PORT_PORT_POSIX_H_
	#define STORAGE_LEVELDB_PORT_PORT_POSIX_H_

	#undef PLATFORM_IS_LITTLE_ENDIAN
	#if defined(OS_MACOSX)
	#include <machine/endian.h>
	#if defined(__DARWIN_LITTLE_ENDIAN) && defined(__DARWIN_BYTE_ORDER)
	#define PLATFORM_IS_LITTLE_ENDIAN \
	(__DARWIN_BYTE_ORDER == __DARWIN_LITTLE_ENDIAN)
	#endif
	#elif defined(OS_SOLARIS)
	#include <sys/isa_defs.h>
	#ifdef _LITTLE_ENDIAN
	#define PLATFORM_IS_LITTLE_ENDIAN true
	#else
	#define PLATFORM_IS_LITTLE_ENDIAN false
	#endif
	#elif defined(OS_FREEBSD)
	#include <sys/types.h>
	#include <sys/endian.h>
	#define PLATFORM_IS_LITTLE_ENDIAN (_BYTE_ORDER == _LITTLE_ENDIAN)
	#elif defined(OS_OPENBSD) \|\| defined(OS_NETBSD) \|\|\
	- defined(OS_DRAGONFLYBSD) \|\| defined(OS_ANDROID)
	+ defined(OS_DRAGONFLYBSD)
	#include <sys/types.h>
	#include <sys/endian.h>
	#elif defined(OS_HPUX)
	#define PLATFORM_IS_LITTLE_ENDIAN false
	+#elif defined(OS_ANDROID)
	+ // Due to a bug in the NDK x86 <sys/endian.h> definition,
	+ // _BYTE_ORDER must be used instead of __BYTE_ORDER on Android.
	+ // See http://code.google.com/p/android/issues/detail?id=39824
	+ #include <endian.h>
	+ #define PLATFORM_IS_LITTLE_ENDIAN (_BYTE_ORDER == _LITTLE_ENDIAN)
	#else
	#include <endian.h>
	#endif

	#include <pthread.h>
	#ifdef SNAPPY
	#include <snappy.h>
	#endif
	#include <stdint.h>
	#include <string>
	#include "port/atomic_pointer.h"

	#ifndef PLATFORM_IS_LITTLE_ENDIAN
	#define PLATFORM_IS_LITTLE_ENDIAN (__BYTE_ORDER == __LITTLE_ENDIAN)
	#endif

	#if defined(OS_MACOSX) \|\| defined(OS_SOLARIS) \|\| defined(OS_FREEBSD) \|\|\
	defined(OS_NETBSD) \|\| defined(OS_OPENBSD) \|\| defined(OS_DRAGONFLYBSD) \|\|\
	defined(OS_ANDROID) \|\| defined(OS_HPUX)
	// Use fread/fwrite/fflush on platforms without _unlocked variants
	#define fread_unlocked fread
	#define fwrite_unlocked fwrite
	#define fflush_unlocked fflush
	#endif

	#if defined(OS_MACOSX) \|\| defined(OS_FREEBSD) \|\|\
	defined(OS_OPENBSD) \|\| defined(OS_DRAGONFLYBSD)
	// Use fsync() on platforms without fdatasync()
	#define fdatasync fsync
	#endif

	#if defined(OS_ANDROID) && __ANDROID_API__ < 9
	// fdatasync() was only introduced in API level 9 on Android. Use fsync()
	// when targetting older platforms.
	#define fdatasync fsync
	#endif

	namespace leveldb {
	namespace port {

	static const bool kLittleEndian = PLATFORM_IS_LITTLE_ENDIAN;
	#undef PLATFORM_IS_LITTLE_ENDIAN

	class CondVar;

	class Mutex {
	public:
	Mutex();
	~Mutex();

	void Lock();
	void Unlock();
	void AssertHeld() { }

	private:
	friend class CondVar;
	pthread_mutex_t mu_;

	// No copying
	Mutex(const Mutex&);
	void operator=(const Mutex&);
	};

	class CondVar {
	public:
	explicit CondVar(Mutex* mu);
	~CondVar();
	void Wait();
	void Signal();
	void SignalAll();
	private:
	pthread_cond_t cv_;
	Mutex* mu_;
	};

	typedef pthread_once_t OnceType;
	#define LEVELDB_ONCE_INIT PTHREAD_ONCE_INIT
	extern void InitOnce(OnceType* once, void (*initializer)());

	inline bool Snappy_Compress(const char* input, size_t length,
	::std::string* output) {
	#ifdef SNAPPY
	output->resize(snappy::MaxCompressedLength(length));
	size_t outlen;
	snappy::RawCompress(input, length, &(*output)[0], &outlen);
	output->resize(outlen);
	return true;
	#endif

	return false;
	}

	inline bool Snappy_GetUncompressedLength(const char* input, size_t length,
	size_t* result) {
	#ifdef SNAPPY
	return snappy::GetUncompressedLength(input, length, result);
	#else
	return false;
	#endif
	}

	inline bool Snappy_Uncompress(const char* input, size_t length,
	char* output) {
	#ifdef SNAPPY
	return snappy::RawUncompress(input, length, output);
	#else
	return false;
	#endif
	}

	inline bool GetHeapProfile(void (func)(void, const char, int), void arg) {
	return false;
	}

	} // namespace port
	} // namespace leveldb

	#endif // STORAGE_LEVELDB_PORT_PORT_POSIX_H_

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 10:13 (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187310
Default Alt Text: (32 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions