Sqlite.xcsm

浏览该文件的文档.

//xlang Source, Name:Sqlite.xcsm 
//Date: Wed Mar 00:26:43 2019 
 
 
class Sqlite : Sql.Connection{
    static const String DRIVERNAME = "sqlite";
            
    public static bool registry(){
        if (Native.init()){
            Sql.Database.reigstry(DRIVERNAME, new SqliteRegister());
            return true;
        }
        return false;
    }
      
 
    static class SqliteRegister : Sql.ConnectionRegister{
        Sql.Connection allocConnection(String drivername)override{
            if (drivername.equals("sqlite")){
                return new Sqlite();
            }
            return nilptr;
        }
    };
    
    
    public static class CSTDNative : Library{
        static bool loaded = false;
        public static bool load(){
            if (loaded == false){
                int cstd_os = _system_.getPlatformId();
                try{
                    if (cstd_os == _system_.PLATFORM_WINDOWS){
                        loadLibrary("ntdll.dll");
                    }else
                    if (cstd_os == _system_.PLATFORM_LINUX){
                        loadLibrary("libc.so.6");
                    }else
                    if (cstd_os == _system_.PLATFORM_MACOSX){
                        loadLibrary("libc.dylib");
                    }
                    loaded = true;
                }catch(Exception e){
                    _system_.output(e.getMessage());
                }
            }
            return loaded;
        }
        public import{
            Pointer cdecl memcpy(ObjectPtr dest, Pointer src, Pointer n);
            Pointer cdecl strcpy(ObjectPtr dest, ObjectPtr src);
            Pointer cdecl strlen(Pointer);
        };
    };
    static class Native : Library{
        static bool bloaded = false;
        
        public static bool init(){
            if (bloaded == false){
                if (CSTDNative.load()){
                    try{
                        loadLibrary("sqlite3");
                        bloaded = true;
                    }catch(Exception e){
                        _system_.output(e.getMessage());
                    }
                }
            }
            return bloaded;
        }
        
        public import {
            int cdecl sqlite3_open(
                  String filename,   /* Database filename (UTF-8) */
                  ObjectPtr ppDb          /* OUT: SQLite db handle */
                );
                
            /*int cdecl sqlite3_key(
              Pointer db,                   /* Database to be rekeyed * /
              String pKey, int nKey     /* The key * /
            );*/
            
            int cdecl sqlite3_close(
              Pointer db);
            int cdecl sqlite3_step(long pStmt);
            int cdecl sqlite3_exec(
              Pointer db,                                  /* An open database */
              String sql,                           /* SQL to be evaluated */
              Pointer ,  /* Callback function */
              Pointer ,                                    /* 1st argument to callback */
              ObjectPtr msg                              /* Error msg written here */
            );
            int cdecl sqlite3_prepare(
              Pointer db,              /* Database handle. */
              String zSql,         /* UTF-8 encoded SQL statement. */
              int nBytes,               /* Length of zSql in bytes. */
              ObjectPtr ppStmt,    /* OUT: A pointer to the prepared statement */
              ObjectPtr pzTail       /* OUT: End of parsed string */
            );
            int cdecl sqlite3_prepare_v2(
              Pointer db,              /* Database handle. */
              String zSql,         /* UTF-8 encoded SQL statement. */
              int nBytes,               /* Length of zSql in bytes. */
              ObjectPtr ppStmt,    /* OUT: A pointer to the prepared statement */
              ObjectPtr pzTail       /* OUT: End of parsed string */
            );
            int cdecl sqlite3_reset(Pointer pStmt);
            int cdecl sqlite3_bind_int(Pointer pStmt, int, int);
            int cdecl sqlite3_bind_int64(Pointer pStmt, int, long);
            int cdecl sqlite3_bind_double(Pointer pStmt, int, double);
            int cdecl sqlite3_bind_null(Pointer pStmt, int);
            int cdecl sqlite3_bind_text(Pointer pStmt, int, String, int , Pointer);
            int cdecl sqlite3_bind_blob(Pointer pStmt, int ,ObjectPtr, int , Pointer);
            String cdecl sqlite3_errmsg(Pointer pStmt);
            int cdecl sqlite3_errcode(Pointer db);
            int cdecl sqlite3_column_int(Pointer pStmt, int i);
            int cdecl sqlite3_changes(Pointer pStmt);
            double cdecl sqlite3_column_double(Pointer pStmt, int i);
            long cdecl sqlite3_column_int64(Pointer pStmt, int i);
            String cdecl sqlite3_column_text(Pointer pStmt, int i);
            int cdecl sqlite3_column_count(Pointer pStmt);
            String cdecl sqlite3_column_name(Pointer pStmt, int N);
            String cdecl sqlite3_column_decltype(Pointer pStmt, int N);
            int cdecl sqlite3_finalize(Pointer pStmt);
            long cdecl sqlite3_last_insert_rowid(Pointer pStmt);
        };
    };
 
    static bool registried = registry();
    long hdb = 0;
    
    public void create(String uri, String username, String pwd)override{
        int err = Native.sqlite3_open(uri, hdb);
        if (err != 0){
            throw new Sql.SqlException(err, "can not open database:" + uri);
        }
        /*if (pwd != nilptr){
            err = Native.sqlite3_key(hdb, pwd, pwd.length());
            if (err != 0){
                throw new Sql.SqlException(err, "password incorrect");
            }
        }*/
    }
    
    public void setOption(int opt, Object option)override{
        throw new Sql.DatabaseNotSupportException("setOption");
    }
    
    public void throw_sqlite_error(){
        throw new Sql.SqlException(getErrorCode(),__file__ + ":" +  __line__ + ", SQLITE: " +  getError() );
    }
    public int getErrorCode()override{
        return Native.sqlite3_errcode(hdb);
    }
    
    public String getError()override{
        return Native.sqlite3_errmsg(hdb);
    }
    
    public Object getOption(int opt)override{
        throw new Sql.DatabaseNotSupportException("getOption");
        return nilptr;
    }
    
    public Sql.PreparedStatement prepareStatement(String sql)override{
        return new SqlitePreparedStatement(this, sql);
    }
    
    public Sql.Statement createStatement()override{
        return new SqlitePreparedStatement(this);
    }
    
    public bool isClosed()override{
        return hdb != 0;
    }
 
    public long getLastInsertedRowId(){
        return Native.sqlite3_last_insert_rowid(hdb);
    }
    
    public void close()override{
        if (hdb != 0){
            Native.sqlite3_close(hdb);
            hdb = 0;
        }
    }
    
    void finalize(){
        close();
    }
    
    public static const int SYNCHRONOUS_FULL = 2;
    public static const int SYNCHRONOUS_NORMAL = 1;
    public static const int SYNCHRONOUS_OFF = 0;
    
    public int enableSycnhronous(int n){
        if (n < 0 || n > 2){
            return -1;
        }
        String [] cof = {"FULL", "NORMAL", "OFF"};
        return execute("PRAGMA synchronous = " + cof[n] + ";");
    }
    
    public int workBegin(){
        return execute("BEGIN;");
    }
    
    public int commit(){
        return execute("COMMIT;");
    }
    
    public int rollback(){
        return execute("ROLLBACK;");
    }
    
    public String generateErrorText(long herr, String fallback){
        if (herr != 0){
            long len = CSTDNative.strlen(herr);
            byte [] data = new byte[len + 1];
            CSTDNative.memcpy(data, herr, len);
            return new String(data, 0, len);
        }
        return fallback;
    }
    
    public int execute(String stmt){
        if (hdb != 0){
            long msg = 0;
            int err = Native.sqlite3_exec(hdb, stmt, (long)0, (long)0, msg);
            if (err != 0){
                throw_sqlite_error();
            }
            return err;
        }
        throw new Sql.SqlException(-1, "database not opened");
        return -1;
    }
    
    public int get_changes(){
        return Native.sqlite3_changes(hdb);
    }
    
    public long prepare(String sql){
        long nstmt = 0;
        if (hdb != 0){
            int err = Native.sqlite3_prepare_v2(hdb, sql, sql.length(), nstmt, nilptr);
            if (err != 0 || nstmt == 0){
                throw_sqlite_error();
            }
            return nstmt;
        }
        throw new Sql.SqlException(-1, "database not opened");
        return nstmt;
    }
    
    public long getDb(){
        return hdb;
    }
    
 
    public static class SqlitePreparedStatement : Sql.PreparedStatement{
        Sqlite sqlite;
        String sql_text;
        long nstmt = 0;
        int param_pos = 0;
        Vector<Object> stored_params = new Vector<Object>();
        public long getHandle(){
            return nstmt;
        }
        
        public SqlitePreparedStatement(Sqlite db, String sql){
            sqlite = db;
            sql_text = sql;
            nstmt = sqlite.prepare(sql);
        }
        
        public SqlitePreparedStatement(Sqlite db){
            sqlite = db;
        }
        
        public int execute(String sql)override{
            return sqlite.execute(sql);
        }
        
        public bool reset(){
            return Native.sqlite3_reset(nstmt) == 0;
        }
        public int executeUpdate()override{
            int r = Native.sqlite3_step(nstmt);
            if (101 == r){
                return 0;
            }
            return r;
        }
        
        public int execute()override{
            int r = Native.sqlite3_step(nstmt);
            if (101 == r){
                return 0;
            }
            return r;
        }
        
        public Sql.ResultSet executeQuery()override{
            return new SqliteResultSet(sqlite, this);
        }
        
        public Sql.ResultSet executeQuery(String sql)override{
            nstmt = sqlite.prepare(sql);
            return new SqliteResultSet(sqlite, this);
        }
        
        public int executeUpdate(String sql)override{
            return sqlite.execute(sql);
        }
        
        public int get_changes()override{
            return sqlite.get_changes();
        }
        
        public Sql.ResultSet getResult()override{
            throw new Sql.DatabaseNotSupportException("getResult");
            return nilptr;
        }
        
        public void close()override{
            if (nstmt != 0){
                Native.sqlite3_finalize(nstmt);
                nstmt = 0;
            }
            sqlite = nilptr;
        }
        
        
        public void setValue(String value)override{
            stored_params.add(value);
            int res = 0;
            if (value != nilptr){
                res = Native.sqlite3_bind_text(nstmt, ++param_pos, value, value.length(), nilptr);
                if (0 != res){
                    sqlite.throw_sqlite_error();
                }
            }else{
                res = Native.sqlite3_bind_null(nstmt, ++param_pos);
                if (0 != res){
                    sqlite.throw_sqlite_error();
                }
            }
        }
        
        public void setValue(int value)override{
            int res = Native.sqlite3_bind_int(nstmt, ++param_pos, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        public void setValue(long value)override{
            int res = Native.sqlite3_bind_int64(nstmt, ++param_pos, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        public void setValue(byte value)override{
            int res = Native.sqlite3_bind_int(nstmt, ++param_pos, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        public void setValue(double value)override{
            int res = Native.sqlite3_bind_double(nstmt, ++param_pos, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        
        public void setValue(int id, String value)override{
            stored_params.add(value);
            int res = 0;
            if (value != nilptr){
                res = Native.sqlite3_bind_text(nstmt, id, value, value.length(), nilptr);
                if (0 != res){
                    sqlite.throw_sqlite_error();
                }
            }else{
                res = Native.sqlite3_bind_null(nstmt, id);
                if (0 != res){
                    sqlite.throw_sqlite_error();
                }
            }
        }
        
        public void setValue(int id, int value)override{
            int res = Native.sqlite3_bind_int(nstmt, id, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        public void setValue(int id, long value)override{
            int res = Native.sqlite3_bind_int64(nstmt, id, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        public void setValue(int id, byte value)override{
            int res = Native.sqlite3_bind_int(nstmt, id, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        public void setValue(int id, double value)override{
            int res = Native.sqlite3_bind_double(nstmt, id, value);
            if (0 != res){
                sqlite.throw_sqlite_error();
            }
        }
        
        public void setValues(Object [] args)override{
            for (int i = 0; i < args.length; i++){
                if (args[i].instanceOf(String)){
                    stored_params.add(args[i]);
                    setValue((String)args[i]);
                }else
                if (args[i].instanceOf(int)){
                    setValue((int)args[i]);
                }else
                if (args[i].instanceOf(long)){
                    setValue((long)args[i]);
                }else
                if (args[i].instanceOf(byte)){
                    setValue((byte)args[i]);
                }else
                if (args[i].instanceOf(double)){
                    setValue((double)args[i]);
                }else{
                    throw new Sql.SqlException(-1, "sql " + sql_text + " dont accept type:" + i);
                }
            }
        }
    };
    
    public static class SqliteResultSet : Sql.ResultSet{
        Sqlite sqlite;
        SqlitePreparedStatement sps;
        Map<String, int> __fields_Map = new Map<String, int>();
                
        public SqliteResultSet(Sqlite db, SqlitePreparedStatement _sps){
            sqlite = db;
            sps = _sps;
            parseResult();
        }
        
        public int getColumnCount()override{
            return Native.sqlite3_column_count(sps.getHandle());
        }
        
        public String getColumnName(int n)override{
            return Native.sqlite3_column_name(sps.getHandle(), n);
        }
        
        public void parseResult(){
            int ncolumn = Native.sqlite3_column_count(sps.getHandle());
            for (int i = 0; i < ncolumn; i++){
                String colutext = Native.sqlite3_column_name(sps.getHandle(), i);
                __fields_Map.put(colutext, i);
            }
        }
        
        public int label2idx(String label){
            return __fields_Map.get(label);
        }
        
        public bool first()override{
            throw new Sql.DatabaseNotSupportException("first");
            return false;
        }
        
        public bool last()override{
            throw new Sql.DatabaseNotSupportException("last");
            return false;
        }
 
        public bool next()override{
            int code = Native.sqlite3_step(sps.getHandle());
            return 100 == code;
        }
        
        public bool previous()override{
            throw new Sql.DatabaseNotSupportException("previous");
            return false;
        }
        
        public bool isFirst()override{
            throw new Sql.DatabaseNotSupportException("isFirst");
            return false;
        }
        
        public bool isLast()override{
            throw new Sql.DatabaseNotSupportException("isLast");
            return false;
        }
        
        public bool isValid()override{
            return sps != nilptr && (sps.getHandle() != 0);
        }
        
        public bool isEof()override{
            throw new Sql.DatabaseNotSupportException("isEof");
            return false;
        }
        
        public int getInt(String columnlabel)override{
            return Native.sqlite3_column_int(sps.getHandle(), label2idx(columnlabel));
        }
        
        public long getLong(String columnlabel)override{
            return Native.sqlite3_column_int64(sps.getHandle(), label2idx(columnlabel));
        }
        
        public double getDouble(String columnlabel)override{
            return Native.sqlite3_column_double(sps.getHandle(), label2idx(columnlabel));
        }
        
        public float getFloat(String columnlabel)override{
            return getString(columnlabel).parseFloat();
        }
        
        public byte getByte(String columnlabel)override{
            return Native.sqlite3_column_int(sps.getHandle(), label2idx(columnlabel));
        }
        
        public bool getBoolean(String columnlabel)override{
            return Native.sqlite3_column_int(sps.getHandle(), label2idx(columnlabel)) != 0;
        }
        
        public String getString(String columnlabel)override{
            return Native.sqlite3_column_text(sps.getHandle(), label2idx(columnlabel));
        }
        
        public int getInt(int columnIndex)override{
            return Native.sqlite3_column_int(sps.getHandle(), columnIndex);
        }
        
        public long getLong(int columnIndex)override{
            return Native.sqlite3_column_int64(sps.getHandle(), columnIndex);
        }
        
        public double getDouble(int columnIndex)override{
            return Native.sqlite3_column_double(sps.getHandle(), columnIndex);
        }
        
        public float getFloat(int columnIndex)override{
            return getString(columnIndex).parseFloat();
        }
        
        public byte getByte(int columnIndex)override{
            return Native.sqlite3_column_int(sps.getHandle(), columnIndex);
        }
        
        public bool getBoolean(int columnIndex)override{
            return Native.sqlite3_column_int(sps.getHandle(), columnIndex)!= 0;
        }
        
        public String getString(int columnIndex)override{
            return Native.sqlite3_column_text(sps.getHandle(), columnIndex);
        }
        
 
        
        public int findColumn(String label)override{
            return label2idx(label);
        }
        
        public long getRowCount()override{
            throw new Sql.DatabaseNotSupportException("getRow");
            return 0;
        }
        
        public int getRow()override{
            throw new Sql.DatabaseNotSupportException("getRow");
            return 0;
        }
        
        public void close()override{
 
        }
 
    };
};