rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/RhoRubyLib/db/DBAttrManager.cs

@@ -0,0 +1,92 @@
+using System;
+using rho.common;
+
+namespace rho.db
+{
+    public class DBAttrManager
+    {
+    private Hashtable< int, Hashtable<String,int> > m_mapBlobAttrs = new Hashtable< int, Hashtable<String,int> >();
+    private Hashtable< String, int> m_mapSrcNames = new Hashtable< String, int>();
+
+    public boolean isBlobAttr(int nSrcID, String szAttr)
+    {
+        Hashtable<String,int> mapAttr = m_mapBlobAttrs.get(nSrcID);
+        if ( mapAttr != null )
+            return mapAttr.containsKey(szAttr);
+
+        return false;
+    }
+
+    public boolean hasBlobAttrs()
+    {
+    	return m_mapBlobAttrs.size() > 0;
+    }
+    
+    public int getSrcIDHasBlobsByName(String strName)
+    {
+        if (!m_mapSrcNames.ContainsKey(strName))
+    		return 0;
+
+        int nSrcID = m_mapSrcNames.get(strName);
+        Hashtable<String,int> mapAttr = m_mapBlobAttrs.get(nSrcID);
+        if ( mapAttr.size() == 0 )
+        	return 0;
+        
+    	return nSrcID;
+    }
+    
+    public boolean isOverwriteBlobFromServer(int nSrcID, String strAttr)
+    {
+        Hashtable<String,int> mapAttr = m_mapBlobAttrs.get(nSrcID);
+        if ( mapAttr != null )
+            return mapAttr.get(strAttr) != 0;
+
+        return false;
+    }
+
+    public void loadBlobAttrs(DBAdapter db)
+    {
+        loadAttrs(db, m_mapBlobAttrs, "blob_attribs", m_mapSrcNames);
+        //TODO: update/delete trigger for schema sources
+    }
+    
+    static void loadAttrs(DBAdapter db, Hashtable< int, Hashtable<String,int> > mapAttrs, String strDBAttr,
+        Hashtable<String, int> mapSrcNames)
+    {
+        mapAttrs.clear();
+        String strSql = "SELECT source_id,";
+        strSql += strDBAttr + ",name from sources";
+    	
+	    IDBResult res = db.executeSQL(strSql);
+	    for ( ; !res.isEnd(); res.next() )
+	    { 
+	        int nSrcID = res.getIntByIdx(0);
+	        String strAttribs = res.getStringByIdx(1);
+	        if ( strAttribs.length() == 0 )
+	            continue;
+	
+	        Tokenizer oTokenizer = new Tokenizer( strAttribs, "," );
+	
+	        Hashtable<String,int> mapAttr = new Hashtable<String,int>();
+	        String strAttr = "";
+			while (oTokenizer.hasMoreTokens()) 
+	        {
+				String tok = oTokenizer.nextToken();
+				if (tok.length() == 0)
+					continue;
+	            
+	            if ( strAttr.length() > 0 )
+	            {
+	                mapAttr.put(strAttr, int.Parse(tok) );
+	                strAttr = "";
+	            }else
+	                strAttr = tok;
+	        }
+	
+			mapAttrs.put( nSrcID, mapAttr );
+			if ( mapSrcNames != null )
+				mapSrcNames.put(res.getStringByIdx(2).toUpperCase(), nSrcID);
+	    }
+    }
+    }
+}

data/platform/wp7/RhoRubyLib/db/DBException.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Ink;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+
+namespace rho.db
+{
+    public class DBException : Exception
+    {
+        private int m_errorCode;
+        public int ErrorCode
+        {
+            get { return m_errorCode; }
+            set { m_errorCode = value; }
+        }
+
+        public DBException(Exception exc)
+            : base("Message: " + exc.Message)
+        {
+            m_errorCode = 0;
+	    }
+
+        public DBException(int errorCode, string message)
+            : base(message)
+        {
+            m_errorCode = errorCode;
+        }
+    }
+}

data/platform/wp7/RhoRubyLib/db/IDBCallback.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace rho.db
+{
+    public interface IDBCallback
+    {
+        void onBeforeDelete(String tableName, IDBResult rows2Delete);
+        void onBeforeUpdate(String tableName, IDBResult rows2Insert, int[] cols);
+    }
+}

data/platform/wp7/RhoRubyLib/db/IDBResult.cs

@@ -0,0 +1,33 @@
+using System;
+using rho.common;
+
+namespace rho.db
+{
+    public interface IDBResult : IDisposable
+    {
+    int getColCount();
+	String getColName(int nCol);
+	String getOrigColName(int nCol);
+	
+	//New
+    boolean isEnd();
+    void next();
+	String getStringByIdx(int nCol);
+	int getIntByIdx(int nCol);
+	long getLongByIdx(int nCol);
+	String getUInt64ByIdx(int nCol);
+
+	Object /*RubyValue*/ getRubyValueByIdx(int nCol);
+	boolean isNullByIdx(int nCol);
+	
+	Object /*RubyValue*/ getRubyValue(String colname);
+	int getInt(String colname);
+	String getString(String colname);
+	
+	Object[] getCurData();
+	
+    boolean isNonUnique();
+    
+    void close();
+    }
+}

data/platform/wp7/RhoRubyLib/db/IDBStorage.cs

@@ -0,0 +1,32 @@
+using System;
+using rho.common;
+
+namespace rho.db
+{
+    public interface IDBStorage
+    {
+        void open(String strPath, String strSqlScript, String strEncryptionInfo);
+        void close();
+	
+        IDBResult executeSQL(String strStatement, Object[] values, boolean bReportNonUnique, boolean bNoCopy);
+	
+        void executeBatchSQL(String strStatement);
+	
+        IDBResult createResult();
+	
+        void deleteAllFiles(String strPath);
+	
+        void startTransaction();
+        void commit();
+        void rollback();
+        void onBeforeCommit();
+	
+        void setDbCallback(IDBCallback callback);
+	
+        String[] getAllTableNames();
+        boolean isTableExists(String strName);
+	
+        boolean isDbFileExists(String strPath);
+        void createTriggers();
+    }
+}

data/platform/wp7/RhoRubyLib/db/SqliteCopyResult.cs

@@ -0,0 +1,79 @@
+using System;
+using rho.common;
+
+namespace rho.db
+{
+    public class CSqliteCopyResult
+    {
+        private Vector<Object[]> m_arRows = new Vector<Object[]>();
+	    private int m_nCurPos = 0;
+	    private Vector<String> m_arColumns = new Vector<String>();
+	
+	    public CSqliteCopyResult(IDBResult res)
+	    {
+		    for( int i = 0; i < res.getColCount(); i++)
+			    m_arColumns.addElement(res.getColName(i));
+			
+		    for( ; !res.isEnd(); res.next() )
+		    {
+			    m_arRows.addElement(res.getCurData());
+		    }
+	    }
+
+        public void close()
+	    {
+		    m_arRows = new Vector<Object[]>();
+		    m_nCurPos = 0;
+	    }
+	
+	    public boolean isEnd() 
+	    {
+		    return m_nCurPos >= m_arRows.size(); 
+	    }
+	
+	    public void next()
+	    {
+		    m_nCurPos++;
+	    }
+	
+	    public int getColCount() 
+	    {
+		    return m_arColumns.size();
+	    }
+
+	    public String getColName(int nCol) 
+	    {
+		    return (String)m_arColumns.elementAt(nCol);
+	    }
+
+	    public String getOrigColName(int nCol) 
+	    {
+		    return (String)m_arColumns.elementAt(nCol);
+    	}
+	
+	    public Object[] getCurData()
+	    {
+		    return (Object[])m_arRows.elementAt(m_nCurPos);
+	    }
+
+	    public boolean isNonUnique() {
+		    return false;
+	    }
+
+        public int findColIndex(String colname)
+        {
+            for (int i = 0; i < m_arColumns.size(); i++)
+            {
+                if (((String)m_arColumns.elementAt(i)).equalsIgnoreCase(colname))
+                    return i;
+            }
+
+            return -1;
+        }
+
+        public Object getCurValue(int nCol)
+        {
+    	    return ((Object[])m_arRows.elementAt(m_nCurPos))[nCol];
+        }
+    }
+}

data/platform/wp7/RhoRubyLib/db/SqliteResult.cs

@@ -0,0 +1,267 @@
+using System;
+using System.Net;
+using System.Windows.Shapes;
+using Community.CsharpSqlite;
+using System.Collections;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+using rho.common;
+
+namespace rho.db
+{
+    public class CSqliteResult : IDBResult
+    {
+        private Sqlite3.Vdbe m_st;
+        private CSqliteCopyResult m_resCopy;
+        private boolean m_bNonUnique = false;
+        private boolean m_bNoCopy = false;
+
+        public CSqliteResult()
+        {
+        }
+
+        public CSqliteResult(boolean bNonUnique)
+	    {
+		    m_bNonUnique = bNonUnique;
+	    }
+
+        public CSqliteResult(Sqlite3.Vdbe stmt, boolean bNoCopy)
+        {
+            m_bNoCopy = bNoCopy;
+            m_st = stmt;
+        }
+
+        public boolean isNonUnique()
+        {
+            return m_bNonUnique;
+        }
+
+        public int getColCount()
+        {
+            if (m_resCopy != null)
+                return m_resCopy.getColCount();
+
+            return Sqlite3.sqlite3_data_count(m_st);
+        }
+
+        public String getColName(int nCol)
+        {
+            if (m_resCopy != null)
+                return m_resCopy.getColName(nCol);
+
+            return Sqlite3.sqlite3_column_name(m_st, nCol);
+        }
+
+        public String getOrigColName(int nCol)
+        {
+            if (m_resCopy != null)
+                return m_resCopy.getOrigColName(nCol);
+
+            return Sqlite3.sqlite3_column_name(m_st, nCol);
+        }
+
+        public boolean isEnd()
+        {
+            if (m_resCopy != null)
+                return m_resCopy.isEnd();
+
+            return m_st == null;
+        }
+
+        public void next()
+        {
+            if (m_resCopy != null)
+                m_resCopy.next();
+            else  if (m_st != null)
+            {
+                int res = executeStatement();
+                checkError();
+                if (res != Sqlite3.SQLITE_ROW)
+                    close();
+            }
+        }
+
+        public void checkError()
+        {
+            if (m_st == null)
+                return;
+
+            int res = Sqlite3.sqlite3_errcode(m_st.db);
+            if (res != Sqlite3.SQLITE_OK && res != Sqlite3.SQLITE_ROW && res != Sqlite3.SQLITE_DONE)
+            {
+                close();
+                throw new DBException(res, Sqlite3.sqlite3_errmsg(m_st.db));
+            }
+        }
+
+        public int executeStatement()
+        {
+            int rc = Sqlite3.sqlite3_step(m_st);
+
+            if (rc == Sqlite3.SQLITE_ROW && !m_bNoCopy)
+            {
+                m_resCopy = new CSqliteCopyResult(this);
+                close();
+            }
+
+            return rc;
+        }
+
+        public void Dispose()
+        {
+            close();
+        }
+
+        public void close()
+        {
+            if (m_st != null)
+            {
+                Sqlite3.sqlite3_finalize(ref m_st);
+                m_st = null;
+            }
+        }
+
+        public String getStringByIdx(int nCol)
+        {
+            Object val = getCurValue(nCol);
+            return val != null ? val.ToString() : ""; 
+        }
+
+        public int getIntByIdx(int nCol)
+        {
+            Object val = getCurValue(nCol);
+            return val != null ? Convert.ToInt32(val) : 0; 
+        }
+
+        public long getLongByIdx(int nCol)
+        {
+            Object val = getCurValue(nCol);
+            return val != null ? (long)val : 0; 
+        }
+
+        public String getUInt64ByIdx(int nCol)
+        {
+            return getStringByIdx(nCol);
+        }
+
+        public Object /*RubyValue*/ getRubyValueByIdx(int nCol)
+        {
+            Object val = getCurValue(nCol);
+
+            if (val == null)
+			    return null;
+		    else if ( val is string || val is String)
+                return CRhoRuby.Instance.createString((String)val);
+		    else if ( val is int )
+			    return (int)val;
+		    else if ( val is short )
+			    return (short)val;
+		    else if ( val is long)
+			    return (long)val;
+		    else if ( val is float )
+			    return (float)val;
+		    else if ( val is double)
+			    return (double)val;
+		    else if (val is byte[])
+                return CRhoRuby.Instance.createString(((byte[])val).ToString());
+
+            return CRhoRuby.Instance.createString(val.ToString());
+        }
+
+        public boolean isNullByIdx(int nCol)
+        {
+            Object val = getCurValue(nCol);
+            return val == null; 
+        }
+
+        public Object /*RubyValue*/ getRubyValue(String colname)
+        {
+            return getRubyValueByIdx( findColIndex(colname) );
+        }
+
+        public int getInt(String colname)
+        {
+            return getIntByIdx(findColIndex(colname));
+        }
+
+        public String getString(String colname)
+        {
+            return getStringByIdx(findColIndex(colname));
+        }
+
+        public Object[] getCurData()
+        {
+            if (m_resCopy != null)
+                return m_resCopy.getCurData();
+            
+            String[] cols = getColumnNames();
+            Object[] res = new Object[cols.Length];
+            for (int i = 0; i < cols.Length; i++)
+            {
+                int type = Sqlite3.sqlite3_column_type(m_st, i);
+                switch (type)
+                {
+                    case Sqlite3.SQLITE_INTEGER:
+                        res[i] = Sqlite3.sqlite3_column_int64(m_st, i);
+                        break;
+                    case Sqlite3.SQLITE_FLOAT:
+                        res[i] = Sqlite3.sqlite3_column_double(m_st, i);
+                        break;
+                    case Sqlite3.SQLITE_BLOB:
+                        res[i] = Sqlite3.sqlite3_column_blob(m_st, i);
+                        break;
+                    case Sqlite3.SQLITE_TEXT:
+                        res[i] = Sqlite3.sqlite3_column_text(m_st, i);
+                        if (res[i] == null)
+                            res[i] = String.Empty;
+                        break;
+                    case Sqlite3.SQLITE_NULL:
+                        res[i] = null;
+                        break;
+                }
+            }
+
+            return res;
+        }
+
+        #region Helpers
+
+        private Object getCurValue(int nCol)
+        {
+            if (m_resCopy != null)
+                return m_resCopy.getCurValue(nCol);
+
+            return getCurData()[nCol];
+        }
+
+        private String[] getColumnNames()
+        {
+            int cnt = Sqlite3.sqlite3_data_count(m_st);
+            String[] res = new String[cnt];
+            for (int i = 0; i < cnt; i++)
+            {
+                res[i] = Sqlite3.sqlite3_column_name(m_st, i);
+            }
+
+            return res;
+        }
+
+        private int findColIndex(String colname)
+        {
+            if (m_resCopy != null)
+                return m_resCopy.findColIndex(colname);
+            
+            int cnt = Sqlite3.sqlite3_data_count(m_st);
+
+            for (int i = 0; i < cnt; i++)
+            {
+                if (colname == Sqlite3.sqlite3_column_name(m_st, i))
+                    return i;
+            }
+
+            return - 1;
+        }
+
+        #endregion
+    }
+}