public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var col = this.ReadCollection(db, s);
var query = s.Match("{") ? Query.Query.All() : this.ReadQuery(s);
var code = DynamicCode.GetCode(s);
var docs = col.Find(query).ToArray();
try
{
db.BeginTrans();
foreach (var doc in docs)
{
code(doc["_id"], doc, col, db);
}
db.Commit();
return docs.Length;
}
catch (Exception ex)
{
db.Rollback();
throw ex;
}
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
var col = this.ReadCollection(engine, s);
var newName = s.Scan(@"[\w-]+").ThrowIfEmpty("Invalid new collection name");
display.WriteResult(engine.RenameCollection(col, newName));
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
var col = this.ReadCollection(engine, s);
var doc = JsonSerializer.Deserialize(s.ToString()).AsDocument;
display.WriteResult(engine.Update(col, doc));
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var col = this.ReadCollection(db, s);
var newName = s.Scan(@"[\w-]+");
return db.RenameCollection(col.Name, newName);
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var col = this.ReadCollection(engine, s);
var query = this.ReadQuery(s);
return engine.Delete(col, query);
}
public override void Execute(ref LiteDatabase db, StringScanner s, Display d, InputCommand input)
{
var sb = new StringBuilder();
var enabled = !(s.Scan(@"off\s*").Length > 0);
db.Log.Level = enabled ? Logger.FULL : Logger.NONE;
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var fs = new LiteFileStorage(engine);
var id = this.ReadId(s);
return fs.Delete(id);
}
public static Action<object, BsonDocument, LiteCollection<BsonDocument>, LiteDatabase> GetCode(StringScanner s)
{
var str = s.Scan(@"[\s\S]*");
var code = CODE_TEMPLATE.Replace("[code]", str);
var provider = new CSharpCodeProvider();
var parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("LiteDB.dll");
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
var results = provider.CompileAssemblyFromSource(parameters, code);
if (results.Errors.HasErrors)
{
var err = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
err.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText));
}
throw new InvalidOperationException(err.ToString().Trim());
}
var assembly = results.CompiledAssembly;
var program = assembly.GetType("Program");
var method = program.GetMethod("DoWork");
return new Action<object, BsonDocument, LiteCollection<BsonDocument>, LiteDatabase>((id, doc, col, db) =>
{
method.Invoke(null, new object[] { id, doc, col, db });
});
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var col = this.ReadCollection(engine, s);
var index = s.Scan(this.FieldPattern).Trim();
return engine.Min(col, index.Length == 0 ? "_id" : index);
}
public void StringParsing()
{
string test = @"someSelect[attr-bute= 'this is \' a quoted value']";
scanner = test;
scanner.IgnoreWhitespace = true;
var text = scanner.GetAlpha();
Assert.AreEqual("someSelect", text, "Got first word");
Assert.Throws(typeof(InvalidOperationException), Del(() =>
{
scanner.Expect(MatchFunctions.Quoted);
}), "Bounds don't work with quoted value");
scanner.Expect(MatchFunctions.BoundChar);
text = scanner.Get(MatchFunctions.HTMLAttribute);
Assert.AreEqual("attr-bute", text, "Got attribue");
scanner.ExpectChar('=');
text = scanner.Get(MatchFunctions.Quoted);
Assert.AreEqual("this is ' a quoted value", text, "Got first word");
Assert.AreEqual(scanner.NextChar, ']', "At right postiion");
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var col = this.ReadCollection(db, s);
var index = s.Scan(this.FieldPattern).Trim();
return col.Max(index.Length == 0 ? "_id" : index);
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
var fs = new LiteStorage(engine);
var id = this.ReadId(s);
display.WriteResult(fs.Delete(id));
}
public override void Execute(LiteShell shell, StringScanner s, Display display, InputCommand input)
{
if(s.Scan("false|off").Length > 0 && _writer != null)
{
display.TextWriters.Remove(_writer);
input.OnWrite = null;
_writer.Flush();
_writer.Dispose();
_writer = null;
}
else if(_writer == null)
{
if (shell.Database == null) throw LiteException.NoDatabase();
var dbfilename = shell.Database.ConnectionString.Filename;
var path = Path.Combine(Path.GetDirectoryName(dbfilename),
string.Format("{0}-spool-{1:yyyy-MM-dd-HH-mm}.txt", Path.GetFileNameWithoutExtension(dbfilename), DateTime.Now));
_writer = File.CreateText(path);
display.TextWriters.Add(_writer);
input.OnWrite = (t) => _writer.Write(t);
}
}
public void Execute(LiteEngine engine, StringScanner s, Display d, InputCommand input, Env env)
{
var sb = new StringBuilder();
var enabled = !(s.Scan(@"off\s*").Length > 0);
env.Log.Level = enabled ? Logger.FULL : Logger.NONE;
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
var col = this.ReadCollection(engine, s);
var index = s.Scan(this.FieldPattern).Trim();
display.WriteResult(engine.Max(col, index.Length == 0 ? "_id" : index));
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var col = this.ReadCollection(engine, s);
var doc = JsonSerializer.Deserialize(s).AsDocument;
return engine.Update(col, new BsonDocument[] { doc });
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var col = this.ReadCollection(db, s);
var query = this.ReadQuery(s);
return col.Delete(query);
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var col = this.ReadCollection(engine, s);
var newName = s.Scan(@"[\w-]+").ThrowIfEmpty("Invalid new collection name");
return engine.RenameCollection(col, newName);
}
public override void Execute(ref IShellEngine engine, StringScanner s, Display display, InputCommand input)
{
if (engine == null) throw ShellExpcetion.NoDatabase();
var direction = s.Scan(@"[><]\s*").Trim();
var filename = s.Scan(@".+").Trim();
//dump import
if(direction == "<")
{
using (var reader = new StreamReader(filename, Encoding.UTF8))
{
string line;
while ((line = reader.ReadLine()) != null)
{
engine.Run(line, new Display()); // no output
}
}
}
// dump export
else
{
using (var writer = new StreamWriter(filename, false, Encoding.UTF8, 65536))
{
writer.AutoFlush = true;
writer.WriteLine("-- LiteDB v{0}.{1}.{2} dump file @ {3}",
engine.Version.Major, engine.Version.Minor, engine.Version.Build,
DateTime.Now);
engine.Dump(writer);
writer.Flush();
}
}
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var col = this.ReadCollection(db, s);
var docs = col.GetIndexes();
return new BsonArray(docs);
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var col = this.ReadCollection(db, s);
var doc = JsonSerializer.Deserialize(s).AsDocument;
return col.Update(doc);
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var fs = new LiteFileStorage(engine);
var id = this.ReadId(s);
var metadata = JsonSerializer.Deserialize(s).AsDocument;
return fs.SetMetadata(id, metadata);
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
var cols = db.GetCollectionNames().OrderBy(x => x).ToArray();
if (cols.Length == 0) return BsonValue.Null;
return string.Join(Environment.NewLine, cols);
}
public override void Execute(LiteShell shell, StringScanner s, Display display, InputCommand input)
{
if (shell.Database == null) throw LiteException.NoDatabase();
shell.Database.Dispose();
shell.Database = null;
}
public override void Execute(ref LiteDatabase db, StringScanner s, Display display, InputCommand input)
{
if (db == null) throw LiteException.NoDatabase();
db.Dispose();
db = null;
}
public override void Execute(ref IShellEngine engine, StringScanner s, Display display, InputCommand input)
{
if (engine == null) throw ShellExpcetion.NoDatabase();
engine.Dispose();
engine = null;
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
var fs = new LiteStorage(engine);
var id = this.ReadId(s);
var metadata = JsonSerializer.Deserialize(s.ToString()).AsDocument;
fs.SetMetadata(id, metadata);
}
public Query ReadQuery(StringScanner s)
{
if (s.HasTerminated || s.Match(@"skip\s+\d") || s.Match(@"limit\s+\d"))
{
return Query.All();
}
return this.ReadInlineQuery(s);
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var col = this.ReadCollection(engine, s);
var query = this.ReadQuery(s);
var skipLimit = this.ReadSkipLimit(s);
var docs = engine.Find(col, query, skipLimit.Key, skipLimit.Value);
return new BsonArray(docs);
}
public bool IsCommand(StringScanner s)
{
return(IsCollectionCommand(s, "update"));
}
public bool IsCommand(StringScanner s)
{
return(s.Scan(@"rollback(\s+trans)?$").Length > 0);
}
public override void Execute(ref IShellEngine engine, StringScanner s, Display display, InputCommand input)
{
display.Pretty = !(s.Scan(@"off\s*").Length > 0);
}
public bool IsCommand(StringScanner s)
{
return(s.Match(@"timer$"));
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
return(engine.Shrink());
}
public bool IsFileCommand(StringScanner s, string command)
{
return(s.Scan(@"fs\." + command + @"\s*").Length > 0);
}
public bool IsCommand(StringScanner s)
{
return(this.IsFileCommand(s, "update"));
}
internal static DataStringMainContext ReadFromString(StringScanner scanner)
{
DataStringItem[] items = DataStringItemCollection.ReadFromString(scanner).ToArray();
return(new DataStringMainContext(items));
}
/// <summary>
/// Read collection name from db.(colname).(command)
/// </summary>
public Collection <BsonDocument> ReadCollection(LiteEngine db, StringScanner s)
{
return(db.GetCollection(s.Scan(@"db\.(\w+)\.\w+\s*", 1)));
}
public bool IsCollectionCommand(StringScanner s, string command)
{
return(s.Match(@"db\.\w+\." + command));
}
public bool IsCommand(StringScanner s)
{
return(IsFileCommand(s, "find"));
}
public void Execute(ref LiteEngine db, StringScanner s, Display display)
{
display.WriteBson(this.ReadCollection(db, s).DropIndex(s.Scan(@"\w+").Trim()));
}
public override bool IsCommand(StringScanner s)
{
return(s.Scan(@"close$").Length > 0);
}
/// <summary>
/// Read Id file
/// </summary>
public string ReadId(StringScanner s)
{
return(s.Scan(LiteFileInfo.ID_PATTERN.Substring(1, LiteFileInfo.ID_PATTERN.Length - 2)));
}
public BsonValue Execute(DbEngine engine, StringScanner s)
{
var col = this.ReadCollection(engine, s);
return(new BsonArray(engine.GetIndexes(col).Select(x => x.AsDocument)));
}
public bool IsCommand(StringScanner s)
{
return(s.Scan(@"shrink$").Length > 0);
}
public bool IsCommand(StringScanner s)
{
return(s.Scan(@"userversion\s*").Length > 0);
}
public void Execute(StringScanner s, Env env)
{
env.Input.Timer.Start();
}
public bool IsCommand(StringScanner s)
{
return(this.IsCollectionCommand(s, "insert"));
}
public override void Execute(ref LiteDatabase db, StringScanner s, Display display, InputCommand input)
{
input.Timer.Start();
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
display.Pretty = !(s.Scan(@"off\s*").Length > 0);
}
public override bool IsCommand(StringScanner s)
{
return(s.Scan(@"pretty\s*").Length > 0);
}
public bool IsCommand(StringScanner s)
{
return(s.Scan(@"help\s*").Length > 0);
}
public BsonValue Execute(LiteDatabase db, StringScanner s)
{
db.Rollback();
return(BsonValue.Null);
}
public void Execute(LiteEngine engine, StringScanner s, Display d, InputCommand input, Env env)
{
var sb = new StringBuilder();
var full = s.Match("full");
if (!full)
{
d.WriteHelp("Basic Shell Commands - try `help full` for all commands");
d.WriteHelp("=======================================================");
d.WriteHelp("> open <filename>|<connectionString>", "Open/Crete a new database");
d.WriteHelp("> show collections", "List all collections inside database");
d.WriteHelp("> db.<collection>.insert <jsonDoc>", "Insert a new document into collection");
d.WriteHelp("> db.<collection>.update <jsonDoc>", "Update a document inside collection");
d.WriteHelp("> db.<collection>.delete <filter>", "Delete documents using a filter clausule (see find)");
d.WriteHelp("> db.<collection>.find <filter> [skip N][limit N]", "Show filtered documents based on index search");
d.WriteHelp("> db.<collection>.count <filter>", "Show count rows according query filter");
d.WriteHelp("> db.<collection>.ensureIndex <field> [true|{options}]", "Create a new index document field. For unique key, use true");
d.WriteHelp("> db.<collection>.indexes", "List all indexes in this collection");
d.WriteHelp("<filter> = <field> [=|>|>=|<|<=|!=|like|between] <jsonValue>", "Filter query syntax");
d.WriteHelp("<filter> = (<filter> [and|or] <filter> [and|or] ...)", "Multi queries syntax");
d.WriteHelp("Try:");
d.WriteHelp(" > db.customers.insert { _id:1, name:\"John Doe\", age: 37 }");
d.WriteHelp(" > db.customers.ensureIndex name");
d.WriteHelp(" > db.customers.find name like \"John\"");
d.WriteHelp(" > db.customers.find name like \"John\" and _id between [0, 100] limit 10");
}
else
{
d.WriteHelp("Shell commands");
d.WriteHelp("==============");
d.WriteHelp("> open <filename>|<connectionString>", "Open a new database");
d.WriteHelp("> run <filename>", "Run commands inside filename");
d.WriteHelp("> pretty on|off", "Turns on/off pretty json format");
d.WriteHelp("> timer", "Show timer before prompt");
d.WriteHelp("> ed", "Open notepad with last command to edit and execute");
d.WriteHelp("> spool on|off", "Spool all output in a spool file");
d.WriteHelp("> -- comment", "Do nothing, its just a comment");
d.WriteHelp("> /<command>/", "Support for multi line command");
d.WriteHelp("> debug on|off", "Enabled debug messages from dbengine");
d.WriteHelp("> upgrade <connectionString>", "Upgrade an old datafile (LiteDB v2) to new LiteDB v3 format.");
d.WriteHelp("> version", "Show LiteDB version");
d.WriteHelp("> exit", "Close LiteDB shell");
d.WriteHelp();
d.WriteHelp("Collections commands");
d.WriteHelp("====================");
d.WriteHelp("> show collections", "List all collections inside database");
d.WriteHelp("> db.<collection>.insert <jsonDoc>", "Insert a new document into collection");
d.WriteHelp("> db.<collection>.update <jsonDoc>", "Update a document inside collection");
d.WriteHelp("> db.<collection>.delete <filter>", "Delete documents using a filter clausule (see find)");
d.WriteHelp("> db.<collection>.bulk <filename>", "Bulk insert a json file as documents");
d.WriteHelp("> db.<collection>.find [skip N][limit N]", "Show all documents. Can limit/skip results");
d.WriteHelp("> db.<collection>.find <filter> [skip N][limit N]", "Show filtered documents based on index search. See <filter> syntax below");
d.WriteHelp("> db.<collection>.count <filter>", "Show count rows according query filter");
d.WriteHelp("> db.<collection>.ensureIndex <field> [unique]", "Create a new index document field");
d.WriteHelp("> db.<collection>.indexes", "List all indexes in this collection");
d.WriteHelp("> db.<collection>.drop", "Drop collection and destroy all documents inside");
d.WriteHelp("> db.<collection>.dropIndex <field>", "Drop a index and make index area free to use with another index");
d.WriteHelp("> db.<collection>.rename <newCollectionName>", "Rename a collection");
d.WriteHelp("> db.<collection>.min <field>", "Returns min/first value from collection using index field");
d.WriteHelp("> db.<collection>.max <field>", "Returns max/last value from collection using index field");
d.WriteHelp("> db.<collection>.stats", "Display statistics about a collection");
d.WriteHelp("<filter> = <field> [=|>|>=|<|<=|!=|like|contains|in|between] <jsonValue>", "Filter query syntax");
d.WriteHelp("<filter> = (<filter> [and|or] <filter> [and|or] ...)", "Multi queries syntax");
d.WriteHelp("<jsonDoc> = {_id: ... , key: value, key1: value1 }", "Represent a json (extended version) for a BsonDocument. See special data types");
d.WriteHelp("Json Date", "{ field: { $date :\"2015-01-01T23:59:59Z\"} }");
d.WriteHelp("Json Guid", "{ field: { $guid :\"3a1c34b3-9f66-4d8e-975a-d545d898a4ba\"} }");
d.WriteHelp("Json Int64", "{ field: { $numberLong :\"1234556788997\"} }");
d.WriteHelp("Json Decimal", "{ field: { $numberDecimal :\"123.456789\"} }");
d.WriteHelp("Json Binary", "{ field: { $binary :\"base64 byte array\"} }");
d.WriteHelp();
d.WriteHelp("File storage commands");
d.WriteHelp("=====================");
d.WriteHelp("> fs.find", "List all files on database");
d.WriteHelp("> fs.find <fileId>", "List file info from a key. Supports * for starts with key");
d.WriteHelp("> fs.upload <fileId> <filename>", "Insert a new file inside database");
d.WriteHelp("> fs.download <fileId> <filename>", "Save a file to disk passing a file key and filename");
d.WriteHelp("> fs.update <fileId> {key:value}", "Update metadata file");
d.WriteHelp("> fs.delete <fileId>", "Remove a file inside database");
d.WriteHelp();
d.WriteHelp("Other commands");
d.WriteHelp("==============");
d.WriteHelp("> db.userversion [N]", "Get/Set user database file version");
d.WriteHelp("> db.shrink [password]", "Reduce database removing empty pages and change password (optional)");
}
}
public void Execute(ref LiteEngine db, StringScanner s, Display display)
{
}
public IEnumerable <BsonValue> Execute(StringScanner s, LiteEngine engine)
{
var col = ReadCollection(engine, s);
// single document update
if (s.Match(@"\s*\{"))
{
var doc = JsonSerializer.Deserialize(s.ToString()).AsDocument;
s.ThrowIfNotFinish();
yield return(engine.Update(col, doc));
}
// query update
else
{
// db.colName.update
// field = value,
// array += valueToAdd,
// where _id = 1
// and ...
var updates = new List <UpdateData>();
var query = Query.All();
while (!s.HasTerminated)
{
var path = BsonExpression.ReadExpression(s, true, true).Source;
var action = s.Scan(@"\s*\+?=\s*").Trim().ThrowIfEmpty("Invalid operator (support = or +=)", s);
var value = ReadBsonValue(s);
var expr = value == null?BsonExpression.ReadExpression(s, true, false) : null;
if (action != "+=" && action != "=")
{
throw LiteException.SyntaxError(s);
}
if (value == null && expr == null)
{
throw LiteException.SyntaxError(s);
}
updates.Add(new UpdateData {
Path = path, Value = value, Expr = expr, Add = action == "+="
});
s.Scan(@"\s*");
if (s.Scan(@",\s*").Length > 0)
{
continue;
}
else if (s.Scan(@"where\s*").Length > 0 || s.HasTerminated)
{
break;
}
else
{
throw LiteException.SyntaxError(s);
}
}
if (!s.HasTerminated)
{
query = ReadQuery(s, false);
}
s.ThrowIfNotFinish();
// fetch documents to update
var count = engine.Update(col, FetchDocuments(engine, col, query, updates));
yield return(count);
}
}
public override bool IsCommand(StringScanner s)
{
return(s.Match(@"--"));
}
public override void Execute(LiteShell shell, StringScanner s, Display display, InputCommand input)
{
}
public bool IsCommand(StringScanner s)
{
return(this.IsCollectionCommand(s, "ensure[iI]ndex"));
}
public void Execute(LiteEngine engine, StringScanner s, Display display, InputCommand input, Env env)
{
var col = this.ReadCollection(engine, s);
var query = this.ReadQuery(s);
display.WriteResult(engine.Delete(col, query));
}
