分类导航

程序问答发布时间：2022-06-02 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了如何使用 Dart 连接 Microsoft SQL Server，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

如何解决如何使用 Dart 连接 Microsoft SQL Server？

开发过程中遇到如何使用 Dart 连接 Microsoft SQL Server的问题如何解决？下面主要结合日常开发的经验，给出你关于如何使用 Dart 连接 Microsoft SQL Server的解决方法建议，希望对你解决如何使用 Dart 连接 Microsoft SQL Server有所启发或帮助；

谁能告诉我如何使用 Dart 连接到 sql Server 数据库？我已经阅读和搜索了好几天，但找不到任何合适的答案。

今天我一直在测试这个： https://github.com/nippur72/SqlServerSocket 它有效，但现在我在代码中出现错误：

在名为 sqlconnection 的 git 文件中我得到了这个函数，当我返回时出现以下错误：

套接字sql： here you can see that he really listens

错误：

type 'Future<dynamic>' is not a subtype of type 'Future<String>'

代码：

   /// formats and write a command to the socket
   Future<String> _SendCommand(String command)
   {
      // prepare buffer for response
      _receiveBuffer = new StringBuffer();
      
      _completer = new Completer();
      String cmd = command.length.toString() + "\r\n" + command;
      _socket.write(cmd);

      return _completer.future; // this line return to ComprobarConnexio() and get error
   }

主要代码

voID main() async{
  runApp(MyApp());
  ComprobarConnexion();
}

class MyApp extends StatelessWidget{
  @overrIDe
  Widget build(BuildContext context){
    return new MaterialApp(
      deBUGShowcheckedModeBAnner: false,home: MainMenu(),theme: new themeData(
        FontFamily: 'San Francisco',priMarycolor: color.fromrGBO(51,51,1),),);
  }
 }
 ComprobarConnexion() async {
   var conn = new sqlConnection("SERVER=****;Database=***;UID=****;password=****",address: '****',port: ****);
  print(Text('StarTing connection'),);
  try {
    await conn.open();
    print(Text('Connection OPEN!'),);
  }
  catch(E){
     print(E);
     print(Text('Connection Failed'),);
  }
  await conn.close();
  print(Text('Connection Closed'),);

}

解决方法

我发现了这个问题，这是一个 github 代码错误，我把 git 代码留在这里，以防有人发现和我一样，谢谢大家的帮助。

文件：sqlConnection.dart


library sql_server_socket;

import "dart:io";
import "dart:async";
import "dart:convert";

import "table.dart";

class SqlConnection
{
   Socket _socket;
   StringBuffer _receiveBuffer;
   Completer _completer;
   bool _connected;
   
   String _address;
   int _port;
   String _connectionString;
   
   SqlConnection(String connStr,{String address: "localhost",int port: 10980})
   {
      _address = address;
      _port = port;
      _connected = false;
      _connectionString = connStr;
   }
   
   /// tells if Database is connected
   bool get connected => _connected;  
   
   /// connects to sql server database using the specified connection String
   Future<dynamic> open() async
   {
      try
      {
         this._socket = await Socket.connect(_address,_port);
         print("Connected to: ${_socket.remoteAddress.address}:${_socket.remotePort}");
      }
      catch(eX)
      {
         throw "can't connect to ${_address}:${_port} -- $ex";         
      }
       
      //Establish the onData,and onDone callBACks
      utf8.decoder.bind(_socket).listen(_receiveData,onError: _onError,onDone: _onDonE);

      var connectCompleter = new Completer();
      
      String JSON = json.encode({ "type": "open","text": _connectionString });
      
      _SendCommand(JSON).then((result)
      {
         var res = _parseResult(result);
         if(res is _OkResult)
         {
           _connected = true;
           connectCompleter.complete(true);
         }
         else if(res is _ErrorResult)
         {
           _connected = false;
           connectCompleter.completeError(res.error);         
         }
         else throw "unknown response";
      })
      .catchError((err)
      {
         _connected = false;
         connectCompleter.completeError(err);
      });         
       
      return connectCompleter.future;
   }
   
   /// disconnects from sql server
   Future<dynamic> close()
   {
      if(!connected) throw "not connected";
      
      Completer disconnectCompleter = new Completer();
      
      String JSON = json.encode({ "type": "close","text": "" });
      
      _SendCommand(JSON).then((risp)
      {
         var res = _parseResult(risp);
         
         if(res is _OkResult) 
         {
            _connected = false;
            disconnectCompleter.complete(true);
         }
         else if(res is _ErrorResult)
         {           
            disconnectCompleter.completeError(res.error);           
         }
         else throw "unknown response";
      })
      .catchError((err)
      {
        disconnectCompleter.completeError(err);    
      });               
      
      return disconnectCompleter.future;     
   }
   
   /// launch a query on the database,returning a table
   Future<Table> queryTable(String sql)
   {      
      if(!connected) throw "not connected";
      
      String JSON = json.encode({ "type": "table","text": SQL });
      
      Completer compl = new Completer(); 
      _SendCommand(JSON).then((result)
      {
          var res = _parseResult(result);

               if(res is _ErrorResult) compl.completeError(res.error);          
          else if(res is _TableResult) 
          {
              var tres = res as _TableResult;              
              Table tab = new Table(this,tres.tablename,tres.rows,tres.columns);
              compl.complete(tab);
          }
          else throw "unknown response";
      })
      .catchError((err)
      {
          compl.completeError(err);  
      });
      return compl.future;
   }

   Future<PostBACkResponse> postBACk(ChangeSet chg)
   {      
      if(!connected) throw "not connected";
      
      String params = json.encode(chg.toEncodable());
      
      String JSON = json.encode({ "type": "postBACk","text": params });
      
      Completer compl = new Completer(); 
      _SendCommand(JSON).then((result)
      {
          var res = _parseResult(result);

               if(res is _ErrorResult) compl.completeError(res.error);          
          else if(res is _PostBACkResult) 
          {
              var tres = res as _PostBACkResult; 
              PostBACkResponse resp = new PostBACkResponse();
              resp.idcolumn = tres.idcolumn;
              resp.identities = tres.identities;              
              compl.complete(resp);
          }
          else throw "invalid postBACk response";
      })
      .catchError((err)
      {
          compl.completeError(err);  
      });
      return compl.future;           
   }
   
   /// launch a query on the database,returning all rows
   Future<List<Map<String,dynamic>>> query(String sql)
   {      
      if(!connected) throw "not connected";
      
      String JSON = json.encode({ "type": "query","text": SQL });
      
      Completer compl = new Completer(); 
      _SendCommand(JSON).then((result)
      {
          var res = _parseResult(result);
               if(res is _ErrorResult) compl.completeError(res.error);         
          else if(res is _QueryResult) compl.complete(res.rows);          
          else throw "unknown response";
      })
      .catchError((err)
      {
          compl.completeError(err);  
      });
      return compl.future;
   }
   
   /// launch a query on the database,returning the first rows only
   Future<dynamic> querySingle(String sql)
   {      
      if(!connected) throw "not connected";
      
      String JSON = json.encode({ "type": "querysingle","text": SQL });
      
      Completer compl = new Completer(); 
      _SendCommand(JSON).then((result)
      {
          var res = _parseResult(result);
          
               if(res is _ErrorResult) compl.completeError(res.error);          
          else if(res is _QueryResult)
          {   
              if(res.rows.length==0) compl.complete(null);
              else                   compl.complete(res.rows[0]);
          }
          else throw "unknown response";
      })
      .catchError((err)
      {
          compl.completeError(err);  
      });
      return compl.future;
   }

   /// launch a query on the database,returning the value from the first column of the first row
   Future<dynamic> queryValue(String sql)
   {      
      if(!connected) throw "not connected";
      
      String JSON = json.encode({ "type": "queryvalue","text": SQL });
      
      Completer compl = new Completer(); 
      _SendCommand(JSON).then((result)
      {
          var res = _parseResult(result);

               if(res is _ErrorResult) compl.completeError(res.error);         
          else if(res is _QueryResult)
          {
              if(res.rows.length==0) compl.complete(null);
              else                   compl.complete(res.rows[0]["value"]);
          }
          else throw "unknown response";
      })
      .catchError((err)
      {
          compl.completeError(err);  
      });
      return compl.future;
   }

   /// executes a sql command,returning the number of rows affected
   Future<int> execute(String sql)
   {      
      if(!connected) throw "not connected";
      
      String JSON = json.encode({ "type": "execute","text": SQL });
      
      Completer compl = new Completer(); 
      _SendCommand(JSON).then((result)
      {
          var res = _parseResult(result);
          
               if(res is _ErrorResult) compl.completeError(res.error);          
          else if(res is _QueryResult)
          {
              if(res.rows.length==0) compl.complete(-1);
              else                   compl.complete(res.rows[0]["rowsAffected"]);
          }
          else throw "unknown response";
      })
      .catchError((err)
      {
          compl.completeError(err);  
      });
      return compl.future;
   }

   /// formats and write a command to the socket
   Future<dynamic> _SendCommand(String command)
   {
      // prepare buffer for response
      _receiveBuffer = new StringBuffer();
      
      _completer = new Completer();
      String cmd = command.length.toString() + "\r\n" + command;
      _socket.write(cmd);

      return _completer.future;
   }

   void _onDone()
   {
       //print("onDone()");
       //socket.destroy();
   }
   
   void _onError(error)
   {
       print("error occurred: $error");
   }
   
   /// receive data from socket and build a command String
   /// 
   /// client sends text-based commands with the format:
   /// size_of_command_String + "\r\n" + command_String
   void _receiveData(data)
   {      
      _receiveBuffer.write(data);
            
      String content = _receiveBuffer.toString();
      
      if(content.indexOf("\r\n")>0)
      {
         int x = content.indexOf("\r\n");
         int len = int.parse(content.subString(0,X)); // size of command String
         
         String cmd = content.subString(x+2);
         if(cmd.length==len)
         {           
           _completer.complete(cmd);           
         }              
      }
   }
   
   /// translates generic json result into a Result type
   dynamic _parseResult(String JSON)
   {
      Map result = json.decode(JSON);
      
           if(result["type"]=="ok")       return new _OkResult("ok");      
      else if(result["type"]=="error")    return new _ErrorResult(result["error"]);      
      else if(result["type"]=="query")    return new _QueryResult(result["rows"],result["columns"]);            
      else if(result["type"]=="table")    return new _TableResult(result["tablename"],result["rows"],result["columns"]);
      else if(result["type"]=="postBACk") return new _PostBACkResult(result["idcolumn"],result["identities"]);
      else throw "unknown response";
   }         
}

class _ErrorResult
{
   String error;
   
   _ErrorResult(String error)
   {
      this.error = error;
   }
}

class _OkResult
{
   String ok;
   
   _OkResult(String ok)
   {
      this.ok = ok;
   }
}

class _QueryResult
{
   List rows;
   Map  columns;

   _QueryResult(List rows,Map columns)
   {
      this.rows = rows;
      this.columns = columns;
      
      // fix types 
      for(var fieldName in columns.keys)
      {
         TypeFixer.fixcolumn(rows,fieldName,columns[fieldName]);
      }
   }  
}

class _TableResult
{
   String tableName;
   List rows;   
   List columns;
   
   _TableResult(String tableName,List rows,List columns)
   {
       this.tablename = tablename;
       this.rows = rows;
       this.columns = columns;       
   }
}

class _PostBACkResult
{
   String idcolumn;
   List<int> identities;
   
   _PostBACkResult(String idcolumn,List<int> identities)
   {
       this.idcolumn = idcolumn;
       this.identities = identities;
   }
}

/// translates a JSON encoded SQL type into a Dart type
class TypeFixer
{
   /// fix String data type coming from JSON into proper Dart data type
   static void fixcolumn(List<dynamic> rows,String columnName,String columnTypE)
   {
       if(columnType=="datetiR_28_11845@e")
       {
         for(int t=0;t<rows.length;t++) 
         {
            if(rows[t][columnName]!=null) rows[t][columnName] = datetiR_28_11845@e.parse(rows[t][columnName]);
         }   
       }
   }  
}

大佬总结

以上是大佬教程为你收集整理的如何使用 Dart 连接 Microsoft SQL Server全部内容，希望文章能够帮你解决如何使用 Dart 连接 Microsoft SQL Server所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。

标签：Server 如何使用连接

上一篇: 按主题拆分和解析pdf文件内容下一篇:如何更改菜单项的对齐方式？

猜你在找的程序问答相关文章

在烧瓶中重定向时发出POST请求 2022-06-02
从 CreateWindow() 返回的 HWND 的格式值是多少？ 2022-05-31
使用nodejs打印json对象内容 2022-05-31
useEffect 无限循环仅在测试时发生，否则不会发生 - 尽管使用 useReducer 2022-05-31
从雅虎财经检索 ESG 分数 2022-05-31
Gulp：获取“必须指定任务功能”错误，但我只有 1 个任务 2022-05-31
JavaScript 将平面数组转换为嵌套/分组和排序数组 2022-05-31
405 Method Not Allowed 当提交表单到 Flask 时，即使路由有 ['GET', 'PO... 2022-05-31
Mongodb 错误码和对应的 http 状态码 2022-05-31
连接到上游时 Nginx connect() 失败（111：连接被拒绝），客户端：192.168.128.1，服务... 2022-05-31