opDispatch (WIP), field.name (WIP), stmt.hasRows

Author: cruisercoder

poly/test.d

@@ -32,7 +32,23 @@ unittest {
 
     // these are all heading to test suite
 
-    if (true) {
+    if (true) { //opDispatch
+        auto db = createDatabase("oracle");
+        auto con = db.connection;
+        auto rows = db.query("select * from t").rows;
+
+        foreach (row; rows) {
+            for(int c = 0; c != row.width; ++c) {
+                //log("NAME: ", row[c].name);
+                writeln("a:", row.A);
+                writeln("b:", row.B);
+            }
+            writeln;
+        }
+
+    }
+
+    if (false) {
         auto db = createDatabase;
         auto con1 = db.connection("oracle").autoCommit(false);
         auto con2 = db.connection("oracle").autoCommit(false);
@@ -42,7 +58,7 @@ unittest {
 
         //con1.begin.query("insert into account(id,amount) values(1,100)");
         //con2.begin.query("insert into account(id,amount) values(2,-100)");
-        
+
         con1.commit;
         con2.commit;
     }

src/std/database/common.d

@@ -6,4 +6,58 @@ enum QueryVariableType {
     Named,
 }
 
+// this does not work currently
+// there is one with arrays in in forum
+// but waiting for better options
+/* Support empty Args? */
+@nogc pure nothrow auto toInputRange(Args...)() {
+    struct Range {
+        size_t index;
 
+        bool empty() {return index >= Args.length;}
+        void popFront() {++index;}
+
+        import std.traits : CommonType;
+        alias E = CommonType!Args;
+
+        E front() {
+            final switch (index) {
+                /* static */ foreach (i, arg; Args) {
+                    case i:
+                        writeln("FRONT: ", arg, "INDEX: ", i);
+                        return arg;
+                }
+            }
+        }
+    }
+
+    return Range();
+}
+
+/*
+unittest {
+    import std.traits;
+    import std.range;
+
+
+    static assert(isInputRange!(ReturnType!(toInputRange!(1))));
+
+    static auto foo(Args...)(Args args) {
+        import std.container.array;
+
+        import std.traits : CommonType;
+        alias E = CommonType!Args;
+        writeln("common:", typeid(E));
+
+        return Array!E(toInputRange!(args));
+    }
+    auto a = foo(1,2,3);
+    //assert(a.length == 3 && a[0] == 1 && a[1] == 2 && a[2] == 3);
+    //assert(a.length == 3 && a[0] -);
+
+
+    for(int i = 0; i != a.length; ++i) {
+        writeln("===================HERE: ", a[i]);
+    }
+}
+*/

src/std/database/freetds/database.d

@@ -191,6 +191,9 @@ struct Driver(Policy) {
             query();
         }
 
+        //bool hasRows() {return status != NO_MORE_RESULTS;}
+        bool hasRows() {return true;}
+
         private void bindAll(T...) (T args) {
             //int col;
             //foreach (arg; args) bind(++col, arg);
@@ -241,15 +244,8 @@ struct Driver(Policy) {
         this(Statement* stmt_, int rowArraySize_) {
             stmt = stmt_;
             allocator = stmt.allocator;
-
             status = check("dbresults", dbresults(dbproc));
-            if (!hasResult()) return;
-
             columns = dbnumcols(dbproc);
-            info("COLUMNS:", columns);
-
-            //if (!columns) return;
-
             build_describe();
             build_bind();
         }
@@ -328,8 +324,6 @@ struct Driver(Policy) {
             }
         }
 
-        bool hasResult() {return status != NO_MORE_RESULTS;}
-
         int fetch() {
             status = check("dbnextrow", dbnextrow(dbproc));
             if (status == REG_ROW) {
@@ -341,6 +335,10 @@ struct Driver(Policy) {
             return 0;
         }
 
+        auto name(size_t idx) {
+            return to!string(describe[idx].name);
+        }
+
         auto get(X:string)(Cell* cell) {
             import core.stdc.string: strlen;
             checkType(cell.bind.bindType, NTBSTRINGBIND);

src/std/database/front.d

@@ -81,8 +81,7 @@ struct BasicDatabase(D,P) {
     // go with non-static hasFeature for now to accomidate poly driver
 
     bool hasFeature(Feature feature) {return hasFeature(data_.database, feature);}
-
-    auto ref driverDatabase() {return data_.database;}
+auto ref driverDatabase() {return data_.database;}
 
     private struct Payload {
         string defaultURI;
@@ -258,7 +257,6 @@ struct BasicStatement(D,P) {
     auto query() {
         data_.query();
         state = State.Executed;
-        //return Result(this, rowArraySize_);
         return this;
     }
 
@@ -273,6 +271,8 @@ struct BasicStatement(D,P) {
         return this;
     }
 
+    bool hasRows() {return data_.hasRows;}
+
     // rows()
     // accessor for single rowSet returned
     // length should be the number of rows
@@ -323,12 +323,11 @@ struct BasicResult(D,P) {
     alias Bind = Driver.Bind;
     //alias Row = .Row;
 
-
     this(Statement stmt, int rowArraySize = 1) {
         stmt_ = stmt;
         rowArraySize_ = rowArraySize;
         data_ = Data(&stmt.data_.refCountedPayload(), rowArraySize_);
-        if (!data_.hasResult()) return;
+        if (!stmt_.hasRows) throw new DatabaseException("not a result query");
         rowsFetched_ = data_.fetch();
     }
 
@@ -357,6 +356,18 @@ package:
 
     alias RefCounted!(ResultImpl, RefCountedAutoInitialize.no) Data;
     Data data_;
+
+    // these need to move
+    int width() {return data_.columns;}
+
+    private size_t index(string name) {
+        import std.uni;
+        // slow name lookup, all case insensitive for now
+        for(int i=0; i!=width; i++) {
+            if (sicmp(data_.name(i), name) == 0) return i;
+        }
+        throw new DatabaseException("column name not found:" ~ name);
+    }
 }
 
 struct BasicColumnSet(D,P) {
@@ -500,11 +511,16 @@ struct BasicRow(D,P) {
 
     auto opIndex(Column column) {return opIndex(column.idx);}
 
+    // experimental
+    auto opDispatch(string s)() {
+        return opIndex(rows_.result_.index(s));
+    }
+
     Value opIndex(size_t idx) {
         auto result = &rows_.result_;
         // needs work
         // sending a ptr to cell instead of reference (dangerous)
-        auto cell = Cell(result, &result.data_.bind[idx]);
+        auto cell = Cell(result, &result.data_.bind[idx], idx);
         return Value(result, cell);
     }
 }
@@ -529,7 +545,7 @@ struct BasicValue(D,P) {
     }
 
     private auto resultPtr() {
-        return &result_.result();
+        return &result_.result(); // last parens matter here (something about delegate)
     }
 
     auto type() {return cell_.bind.type;}
@@ -544,6 +560,8 @@ struct BasicValue(D,P) {
 
     bool isNull() {return false;} //fix
 
+    string name() {return resultPtr.name(cell_.idx_);}
+
     auto get(T)() {return Nullable!T(as!T);}
 
     // experimental
@@ -583,10 +601,12 @@ struct BasicCell(D,P) {
     alias Bind = Driver.Bind;
     private Bind* bind_;
     private int rowIdx_;
+    private size_t idx_;
 
-    this(Result *r, Bind *b) {
+    this(Result *r, Bind *b, size_t idx) {
         bind_ = b;
         rowIdx_ = r.rowIdx_;
+        idx_ = idx;
     }
 
     auto bind() {return bind_;}