在这篇文章中，我们将带领您了解Python：受cursor.execute的全貌，包括“SELECT…影响的行数的相关情况。同时，我们还将为您介绍有关ExecuteNonQuery（）返回受影响的C＃

在这篇文章中，我们将带领您了解Python：受cursor.execute的全貌，包括“ SELECT…影响的行数的相关情况。同时，我们还将为您介绍有关ExecuteNonQuery（）返回受影响的C＃的意外行数、Executor 框架（二）Executor 与 ExecutorService 两个基本接口、Executor, ExecutorService 和 Executors 间的不同、Executor, ExecutorService 和 Executors 间的区别与联系的知识，以帮助您更好地理解这个主题。

本文目录一览：

• Python：受cursor.execute（“ SELECT…）影响的行数（python 接受命令行参数）
• ExecuteNonQuery（）返回受影响的C＃的意外行数
• Executor 框架（二）Executor 与 ExecutorService 两个基本接口
• Executor, ExecutorService 和 Executors 间的不同
• Executor, ExecutorService 和 Executors 间的区别与联系

Python：受cursor.execute（“ SELECT…）影响的行数（python 接受命令行参数）

如何访问受以下因素影响的行数：

cursor.execute("SELECT COUNT(*) from result where server_state=''2'' AND name LIKE ''"+digest+"_"+charset+"_%''")

答案1

小编典典

尝试使用fetchone：

cursor.execute("SELECT COUNT(*) from result where server_state=''2'' AND name LIKE ''"+digest+"_"+charset+"_%''")result=cursor.fetchone()

result将包含一个元素为的元组COUNT(*)。因此找到行数：

number_of_rows=result[0]

或者，如果您愿意一口气做到这一点：

cursor.execute("SELECT COUNT(*) from result where server_state=''2'' AND name LIKE ''"+digest+"_"+charset+"_%''")(number_of_rows,)=cursor.fetchone()

PS。最好尽可能使用参数化的参数，因为它可以在需要时自动为您引用参数，并防止sql注入。

参数化参数的正确语法取决于您的python /数据库适配器（例如mysqldb，psycopg2或sqlite3）。看起来像

cursor.execute("SELECT COUNT(*) from result where server_state= %s AND name LIKE %s",[2,digest+"_"+charset+"_%"])(number_of_rows,)=cursor.fetchone()

ExecuteNonQuery（）返回受影响的C＃的意外行数

这是我的代码

      // SqlCommand query = new SqlCommand("INSERT INTO devis (idProposition, identreprise, tauxHoraire, fraisGenerauxMO, fraisGenerauxPiece, beneficeEtAleas, idStatut, prixUnitaireVenteMO ) VALUES(@idproposition,  @identreprise, @tauxHoraire, @fraisGenerauxMO, @fraisGenerauxPiece, @beneficeEtAleas, 1, @prixUnitaireVenteMO) ", Tools.GetConnection());     SqlCommand query = new SqlCommand("INSERT INTO devis (idProposition, identreprise, tauxHoraire, fraisGenerauxMO, fraisGenerauxPiece, beneficeEtAleas, idStatut, prixUnitaireVenteMO, alerteEntrepriseEnvoyee,fraisDeplacement ) VALUES(1051,  85, 20, 2, 2, 2.2, 1, 88,0,-1) ", Tools.GetConnection());    //query.Parameters.AddWithValue("idproposition", this.ID);    //query.Parameters.AddWithValue("identreprise", competitor.ID);    //query.Parameters.AddWithValue("tauxHoraire", competitor.CoefTauxHoraire);    //query.Parameters.AddWithValue("fraisGenerauxMO", competitor.CoefFraisGenerauxMO);    //query.Parameters.AddWithValue("fraisGenerauxPiece", competitor.CoefFraisGenerauxPiece);    //query.Parameters.AddWithValue("beneficeEtAleas", competitor.CoefBeneficeEtAleas);    //query.Parameters.AddWithValue("prixUnitaireVenteMO", Math.Round(competitor.CoefTauxHoraire * competitor.CoefFraisGenerauxMO * competitor.CoefBeneficeEtAleas, 2)); bool insertOK = (query.ExecuteNonQuery() == 1); if (insertOK) {    // DO SOMETHING }

insertOk 为假，但在数据库中插入该行以及我指定的所有信息

我手动重建查询以查看问题是否来自查询。参数，它再次无错误地插入数据库，但insertOk仍然为false！我什至还添加了另外两个不应该为空的字段，但是两种情况下的活动都是相同的

有任何想法吗？

答案1

小编典典

对于UPDATE，INSERT和DELETE语句，返回值是受命令影响的行数。

当要插入或更新的表上存在触发器时，返回值包括受插入或更新操作影响的行数以及受一个或多个触发器影响的行数。对于所有其他类型的语句，返回值为-1。如果发生回滚，则返回值也为-1。

Executor 框架（二）Executor 与 ExecutorService 两个基本接口

一、Executor 接口简介

Executor 接口是 Executor 框架的一个最基本的接口，Executor 框架的大部分类都直接或间接地实现了此接口。

只有一个方法

void execute(Runnable command)： 在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。

Executor 的几种实现原理介绍：

1、 <font color="blue">Executor 接口并没有严格地要求执行是异步的。</font > 在最简单的情况下，执行程序可以在调用者的线程中立即运行已提交的任务：

 class DirectExecutor implements Executor {
     public void execute(Runnable r) {
         r.run();
     }
 }

2、 更常见的是，任务是在某个不是调用者线程的线程中执行的。以下执行程序将为每个任务生成一个新线程。

class ThreadPerTaskExecutor implements Executor {
     public void execute(Runnable r) {
         new Thread(r).start();
     }
 }

3、 许多 Executor 实现都对调度任务的方式和时间强加了某种限制。以下执行程序使任务提交与第二个执行程序保持连续，这说明了一个复合执行程序。

 class SerialExecutor implements Executor {
     private final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
     private  final Executor executor;
     Runnable active;

     SerialExecutor(Executor executor) {
         this.executor = executor;
     }

     public synchronized void execute(final Runnable r) {
         tasks.offer(new Runnable() {
             public void run() {
                 try {
                     r.run();
                 } finally {
                     scheduleNext();
                 }
             }
         });
         if (active == null) {
             scheduleNext();
         }
     }

     protected synchronized void scheduleNext() {
         if ((active = tasks.poll()) != null) {
             executor.execute(active);
         }
     }

 }

二、ExecutorService 接口简介

  ExecutorService 是一个接口，提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 ExecutorService 的实现：

• 三个实现类：AbstractExecutorService（默认实现类） , ScheduledThreadPoolExecutor, ThreadPoolExecutor
• Executors 提供了此接口的几种常用实现的工厂方法。

方法摘要

1. 从 Executor 接口中继承了不跟踪异步线程，没有返回的 execute 方法：

void execute(Runnable command)：
在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。

2. 扩展的跟踪异步线程、返回 Future 接口的实现类的方法：

Future<?> submit(Runnable task)： 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。该 Future 的 get 方法在成功 完成时将会返回 null。

**<T> Future<T> submit(Runnable task,T result)： ** 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。该 Future 的 get 方法在成功完成时将会返回给定的结果。

<T> Future<T> submit(Callable<T> task)： 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。<font color="blue"> 该 Future 的 get 方法在成功完成时将会返回该任务的结果。如果想立即 < font color="red"> 阻塞任务的等待 </font>，则可以使用 result = exec.submit (aCallable).get (); 形式的构造 </font>

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException: 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。返回列表的所有元素的 Future.isDone () 为 true。注意，可以正常地或通过抛出异常来终止已完成 任务。如果正在进行此操作时修改了给定的 collection，则此方法的结果是不确定的。

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout,TimeUnit unit) throws InterruptedException： 超时等待，同上。

<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException,ExecutionException： 与 invokeAll 的区别是，<font color="red"> 任务列表里只要有一个任务完成了，就立即返回。而且一旦正常或异常返回后，则取消尚未完成的任务。</font>

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout,TimeUnit unit) throws InterruptedException： 超时等待，同上。

boolean awaitTermination(long timeout,TimeUnit unit) throws InterruptedException： 一直等待，直到所有任务完成。请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行，或者超时时间的到来 <font color="red"> 如果此执行程序终止，则返回 true；如果终止前超时期满，则返回 false </font>

3. 管理生命周期

void shutdown()： 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。 List<Runnable> shutdownNow()： 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。 无法保证能够停止正在处理的活动执行任务，但是会尽力尝试。例如，<font color="blue"> 在 ThreadPoolExecutor 中，通过 Thread.interrupt () 来取消典型的实现，所以如果任务无法响应中断，则永远无法终止。</font> boolean isShutdown()： 如果此执行程序已关闭，则返回 true。 boolean isTerminated()： 如果关闭后所有任务都已完成，则返回 true。注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。

用法示例

下面给出了一个网络服务的简单结构，这里线程池中的线程作为传入的请求。它使用了预先配置的 Executors.newFixedThreadPool (int) 工厂方法：

class NetworkService implements Runnable {
    private final ServerSocket serverSocket;
    private final ExecutorService pool;

    public NetworkService(int port, int poolSize)
        throws IOException {
      serverSocket = new ServerSocket(port);
      pool = Executors.newFixedThreadPool(poolSize);
    }
 
    public void run() { // run the service
      try {
        for (;;) {
          pool.execute(new Handler(serverSocket.accept()));
        }
      } catch (IOException ex) {
        pool.shutdown();
      }
    }
  }

  class Handler implements Runnable {
    private final Socket socket;
    Handler(Socket socket) { this.socket = socket; }
    public void run() {
      // read and service request on socket
    }
 }
 

<br/>

下列方法分两个阶段关闭 ExecutorService。第一阶段调用 shutdown 拒绝传入任务，然后调用 shutdownNow（如有必要）取消所有遗留的任务：

 void shutdownAndAwaitTermination(ExecutorService pool) {
   pool.shutdown(); // Disable new tasks from being submitted
   try {
     // Wait a while for existing tasks to terminate
     if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
       pool.shutdownNow(); // Cancel currently executing tasks
       // Wait a while for tasks to respond to being cancelled
       if (!pool.awaitTermination(60, TimeUnit.SECONDS))
           System.err.println("Pool did not terminate");
     }
   } catch (InterruptedException ie) {
     // (Re-)Cancel if current thread also interrupted
     pool.shutdownNow();
     // Preserve interrupt status
     Thread.currentThread().interrupt();
   }
 }

参考文献

• 《java 并发编程的艺术》

Executor, ExecutorService 和 Executors 间的不同

UML简要类图关系:

下面详细看一下三者的区别：

Executor vs ExecutorService vs Executors

正如上面所说，这三者均是 Executor 框架中的一部分。Java 开发者很有必要学习和理解他们，以便更高效的使用 Java 提供的不同类型的线程池。总结一下这三者间的区别，以便大家更好的理解：

• Executor 和 ExecutorService 这两个接口主要的区别是：ExecutorService 接口继承了 Executor 接口，是 Executor 的子接口
• Executor 和 ExecutorService 第二个区别是：Executor 接口定义了 execute()方法用来接收一个Runnable接口的对象，而 ExecutorService 接口中的 submit()方法可以接受Runnable和Callable接口的对象。
• Executor 和 ExecutorService 接口第三个区别是 Executor 中的 execute() 方法不返回任何结果，而 ExecutorService 中的 submit()方法可以通过一个 Future 对象返回运算结果。
• Executor 和 ExecutorService 接口第四个区别是除了允许客户端提交一个任务，ExecutorService 还提供用来控制线程池的方法。比如：调用 shutDown() 方法终止线程池。可以通过 《Java Concurrency in Practice》 一书了解更多关于关闭线程池和如何处理 pending 的任务的知识。
• Executors 类提供工厂方法用来创建不同类型的线程池。比如: newSingleThreadExecutor() 创建一个只有一个线程的线程池，newFixedThreadPool(int numOfThreads)来创建固定线程数的线程池，newCachedThreadPool()可以根据需要创建新的线程，但如果已有线程是空闲的会重用已有线程。

总结

下表列出了 Executor 和 ExecutorService 的区别：

Executor	ExecutorService
Executor 是 Java 线程池的核心接口，用来并发执行提交的任务	ExecutorService 是 Executor 接口的扩展，提供了异步执行和关闭线程池的方法
提供execute()方法用来提交任务	提供submit()方法用来提交任务
execute()方法无返回值	submit()方法返回Future对象，可用来获取任务执行结果
不能取消任务	可以通过Future.cancel()取消pending中的任务
没有提供和关闭线程池有关的方法	提供了关闭线程池的方法

Executor, ExecutorService 和 Executors 间的区别与联系

UML 简要类图关系:

下面详细看一下三者的区别：

Executor vs ExecutorService vs Executors

正如上面所说，这三者均是 Executor 框架中的一部分。Java 开发者很有必要学习和理解他们，以便更高效的使用 Java 提供的不同类型的线程池。总结一下这三者间的区别，以便大家更好的理解：

• Executor 和 ExecutorService 这两个接口主要的区别是：ExecutorService 接口继承了 Executor 接口，是 Executor 的子接口
• Executor 和 ExecutorService 第二个区别是：Executor 接口定义了 execute() 方法用来接收一个 Runnable 接口的对象，而 ExecutorService 接口中的 submit() 方法可以接受 Runnable 和 Callable 接口的对象。
• Executor 和 ExecutorService 接口第三个区别是 Executor 中的 execute() 方法不返回任何结果，而 ExecutorService 中的 submit() 方法可以通过一个 Future 对象返回运算结果。
• Executor 和 ExecutorService 接口第四个区别是除了允许客户端提交一个任务，ExecutorService 还提供用来控制线程池的方法。比如：调用 shutDown() 方法终止线程池。可以通过 《Java Concurrency in Practice》 一书了解更多关于关闭线程池和如何处理 pending 的任务的知识。
• Executors 类提供工厂方法用来创建不同类型的线程池。比如: newSingleThreadExecutor() 创建一个只有一个线程的线程池，newFixedThreadPool(int numOfThreads) 来创建固定线程数的线程池，newCachedThreadPool() 可以根据需要创建新的线程，但如果已有线程是空闲的会重用已有线程。

总结

下表列出了 Executor 和 ExecutorService 的区别：

Executor	ExecutorService
Executor 是 Java 线程池的核心接口，用来并发执行提交的任务	ExecutorService 是 Executor 接口的扩展，提供了异步执行和关闭线程池的方法
提供 execute () 方法用来提交任务	提供 submit () 方法用来提交任务
execute () 方法无返回值	submit () 方法返回 Future 对象，可用来获取任务执行结果
不能取消任务	可以通过 Future.cancel () 取消 pending 中的任务
没有提供和关闭线程池有关的方法	提供了关闭线程池的方法

今天关于Python：受cursor.execute和“ SELECT…影响的行数的分享就到这里，希望大家有所收获，若想了解更多关于ExecuteNonQuery（）返回受影响的C＃的意外行数、Executor 框架（二）Executor 与 ExecutorService 两个基本接口、Executor, ExecutorService 和 Executors 间的不同、Executor, ExecutorService 和 Executors 间的区别与联系等相关知识，可以在本站进行查询。

本文标签：

• Python
• cursor.execute
• SELECT语句
• 行数统计