Fix crosslang Stat, StatVFS for custom crosslang filesystems and add queryable

src/runtime_methods/sqlite.cpp

@@ -5,7 +5,7 @@
 namespace Tesses::CrossLang {
     #if defined(TESSESFRAMEWORK_ENABLE_SQLITE)
     using namespace Tesses::Framework::Serialization;
-     TObject Sqlite_Escape(GCList& ls, std::vector<TObject> args)
+    TObject Sqlite_Escape(GCList& ls, std::vector<TObject> args)
     {
         int64_t n;
         double d;
@@ -33,6 +33,58 @@ namespace Tesses::CrossLang {
         return "NULL";
     }
     
+    TObject Sqlite_Prepare(GCList& ls, std::vector<TObject> args)
+    {
+        std::string str;
+        TList* list;
+
+        std::string newStr = "";
+        if(GetArgument(args,0,str) && GetArgumentHeap(args,1,list))
+        {
+            int64_t item = 0;
+
+
+            for(size_t i = 0; i < str.size(); i++)
+            {
+                if(str[i] == '@' && (i+1>=str.size() || str[i+1] != '@'))
+                {
+                    auto v = list->Get(item);
+                    int64_t n;
+                    double d;
+                    bool b;
+
+
+                    std::string str;
+                    if(GetObject(v,str))
+                    {
+                        newStr+= SQLiteDatabase::Escape(str);
+                    }
+                    else if(GetObject(v,n))
+                    {
+                        newStr+= std::to_string(n);
+                    }
+                    else if(GetObject(v,b))
+                    {
+                        newStr+= (b ? "1" : "0");
+                    }
+                    else if(GetObject(v,d))
+                    {
+                        newStr+= std::to_string(d);
+                    }
+                    else {
+
+                    newStr+= "NULL";
+                    }
+                }
+                else {
+                    newStr+=str[i];
+                }
+            }
+
+            
+        }
+        return newStr;
+    }
      
     class SQLiteObject : public TNativeObject
     {   
@@ -65,6 +117,9 @@ namespace Tesses::CrossLang {
                 if(name == "Escape") {
                     return Sqlite_Escape(ls,args);
                 }
+                if(name == "Prepare") {
+                    return Sqlite_Prepare(ls,args);
+                }
                 if(name == "Exec")
                 {
                     std::string arg;
@@ -105,6 +160,7 @@ namespace Tesses::CrossLang {
             }
     };
 
+
     TObject Sqlite_Open(GCList& ls, std::vector<TObject> args,TRootEnvironment* env)
     {
         Tesses::Framework::Filesystem::VFSPath p;
@@ -148,6 +204,7 @@ namespace Tesses::CrossLang {
         }
         return Undefined();
     }
+
     
     #endif
     void TStd::RegisterSqlite(std::shared_ptr<GC> gc,TRootEnvironment* env)
@@ -163,6 +220,7 @@ namespace Tesses::CrossLang {
         dict->DeclareFunction(gc,"Exec","Execute sql (returns dictionary of columns key=value, an error message as string or undefined)",{"handle","sql"},Sqlite_Exec);
         dict->DeclareFunction(gc,"Close","Close sql database",{"handle"},Sqlite_Close);
         dict->DeclareFunction(gc,"Escape","Escape sql text",{"text"},Sqlite_Escape);
+        dict->DeclareFunction(gc,"Prepare", "Prepare sql",{"sql","items"}, Sqlite_Prepare);
        
         gc->BarrierBegin();
         env->DeclareVariable("Sqlite", dict);

src/runtime_methods/std.cpp

@@ -610,6 +610,12 @@ namespace Tesses::CrossLang
         std::shared_ptr<Tesses::Framework::Date::TimeSpan> dt;
         return GetArgument(args,0,dt);
     }
+    static TObject TypeIsQueryable(GCList& ls, std::vector<TObject> args)
+    {
+        if(args.empty()) return nullptr;
+        TQueryable* queryable;
+        return GetArgumentHeap(args,0,queryable);
+    }
     static TObject New_SubdirFilesystem(GCList& ls, std::vector<TObject> args)
     {
         std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
@@ -902,6 +908,7 @@ namespace Tesses::CrossLang
             auto cobj = dynamic_cast<TClassObject*>(obj);
             auto aarray = dynamic_cast<TAssociativeArray*>(obj);
             auto file = dynamic_cast<TFile*>(obj);
+            auto queryable = dynamic_cast<TQueryable*>(obj);
 
             if(rootEnv != nullptr) return "RootEnvironment";
             if(subEnv != nullptr) return "SubEnvironment";
@@ -923,6 +930,7 @@ namespace Tesses::CrossLang
             if(native != nullptr) return "Native";
             if(any != nullptr) return "Any";
             if(file != nullptr) return "File";
+            if(queryable != nullptr) return "Queryable";
 
             return "HeapObject";
         }
@@ -1304,6 +1312,16 @@ namespace Tesses::CrossLang
         return nullptr;
     }
 
+    static TObject New_Queryable(GCList& ls, std::vector<TObject> args)
+    {
+        if(!args.empty())
+        {
+            return TQueryable::Create(ls, args.front());
+        }
+        return nullptr;
+    }
+   
+
     void TStd::RegisterRoot(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
         GCList ls(gc);      
@@ -1430,7 +1448,7 @@ namespace Tesses::CrossLang
         env->DeclareFunction(gc, "TypeIsByteReader","Get whether object is a ByteReader",{"object"},TypeIsByteReader);
         env->DeclareFunction(gc, "TypeIsByteWriter","Get whether object is a ByteWriter",{"object"},TypeIsByteWriter);
         env->DeclareFunction(gc, "TypeIsUuid","Get whether object is a Uuid",{"object"},TypeIsUuid);
-        
+        env->DeclareFunction(gc, "TypeIsQueryable","Get whether object is a Queryable",{"object"},TypeIsQueryable);
         
         newTypes->DeclareFunction(gc, "Regex", "Create regex object",{"regex"},[](GCList& ls,std::vector<TObject> args)->TObject {
             std::string str;
@@ -1476,6 +1494,7 @@ namespace Tesses::CrossLang
             return TAssociativeArray::Create(ls);
         });
         newTypes->DeclareFunction(gc,"ByteArray","Create bytearray, with optional either size (to size it) or string argument (to fill byte array)",{"$data"},ByteArray);
+        newTypes->DeclareFunction(gc, "Queryable", "Create a queryable", {"enumerable"}, New_Queryable);
         
         env->DeclareVariable("Version", TDictionary::Create(ls,{
             TDItem("Parse",TExternalMethod::Create(ls,"Parse version from string",{"versionStr"},[](GCList& ls, std::vector<TObject> args)->TObject{