Your `where` clause will return all rows where `tester` does not match `username` AND where `tester` is not null.

If you want to include NULLs, try:

    where tester &lt;&gt; &#39;username&#39; or tester is null

If you are looking for strings that do not contain the word &quot;username&quot; as a substring, then `like` can be used:

    where tester not like &#39;%username%&#39;

Try the following query

    select * from table
    where NOT (tester = &#39;username&#39;)


NULL-safe condition would looks like:

    select * from table
    where NOT (tester &lt;=&gt; &#39;username&#39;)

    select * from table
    where tester NOT LIKE &#39;%username%&#39;;

The `strcomp` function may be appropriate here (returns 0 when strings are identical):

     SELECT * from table WHERE Strcmp(user, testername) &lt;&gt; 0;


Another way of getting the results 


    SELECT * from table WHERE SUBSTRING(tester, 1, 8)  &lt;&gt; &#39;username&#39; or tester is null



I&#39;m looking for a very simple way to create a Set.

`Arrays.asList(&quot;a&quot;, &quot;b&quot; ...)` creates a `List&lt;String&gt;`

Is there anything similar for `Set` ?

Does .asSet(...) exist in any API?

I recently created a simple application for testing the HTTP call throughput that can be generated in an asynchronous manner vs a classical multithreaded approach.

The application is a able to perform a predefined number of HTTP calls and at the end it displays the total time needed to perform them. During my tests, all HTTP calls were made to my local IIS sever and they retrieved a small text file (12 bytes in size).

The most important part of the code for the asynchronous implementation is listed below:

    public async void TestAsync()
    {
    	this.TestInit();
    	HttpClient httpClient = new HttpClient();
    
    	for (int i = 0; i &lt; NUMBER_OF_REQUESTS; i++)
    	{
    		ProcessUrlAsync(httpClient);
    	}
    }
    
    private async void ProcessUrlAsync(HttpClient httpClient)
    {
    	HttpResponseMessage httpResponse = null;
    
    	try
    	{
    		Task&lt;HttpResponseMessage&gt; getTask = httpClient.GetAsync(URL);
    		httpResponse = await getTask;
    
    		Interlocked.Increment(ref _successfulCalls);
    	}
    	catch (Exception ex)
    	{
    		Interlocked.Increment(ref _failedCalls);
    	}
    	finally
    	{ 
    		if(httpResponse != null) httpResponse.Dispose();
    	}
    
    	lock (_syncLock)
    	{
    		_itemsLeft--;
    		if (_itemsLeft == 0)
    		{
    			_utcEndTime = DateTime.UtcNow;
    			this.DisplayTestResults();
    		}
    	}
    }

The most important part of the multithreading implementation is listed below:

    public void TestParallel2()
    {
    	this.TestInit();
    	ServicePointManager.DefaultConnectionLimit = 100;
    
    	for (int i = 0; i &lt; NUMBER_OF_REQUESTS; i++)
    	{
    		Task.Run(() =&gt;
    		{
    			try
    			{
    				this.PerformWebRequestGet();
    				Interlocked.Increment(ref _successfulCalls);
    			}
    			catch (Exception ex)
    			{
    				Interlocked.Increment(ref _failedCalls);
    			}
    
    			lock (_syncLock)
    			{
    				_itemsLeft--;
    				if (_itemsLeft == 0)
    				{
    					_utcEndTime = DateTime.UtcNow;
    					this.DisplayTestResults();
    				}
    			}
    		});
    	}
    }
    
    private void PerformWebRequestGet()
    { 
    	HttpWebRequest request = null;
    	HttpWebResponse response = null;
    
    	try
    	{
    		request = (HttpWebRequest)WebRequest.Create(URL);
    		request.Method = &quot;GET&quot;;
    		request.KeepAlive = true;
    		response = (HttpWebResponse)request.GetResponse();
    	}
    	finally
    	{
    		if (response != null) response.Close();
    	}
    }

Running the tests revealed that the multithreaded version was faster. It took it around 0.6 seconds to complete for 10k requests, while the async one took around 2 seconds to complete for the same amount of load. This was a bit of a surprise, because I was expecting the async one to be faster. Maybe it was because of the fact that my HTTP calls were very fast. In a real world scenario, where the server should perform a more meaningful operation and where there should also be some network latency, the results might be reversed.

However, what really concerns me is the way HttpClient behaves when the load is increased. Since it takes it around 2 seconds to deliver 10k messages, I thought it would take it around 20 seconds to deliver 10 times the number of messages, but running the test showed that it needs around 50 seconds to deliver the 100k messages. Furthermore, it usually takes it more than 2 minutes to deliver 200k messages and often, a few thousands of them (3-4k) fail with the following exception:

&gt;    An operation on a socket could not be performed because the system lacked sufficient buffer space or because a queue was full.

I checked the IIS logs and operations that failed never got to the server. They failed within the client. I ran the tests on a Windows 7 machine with the default range of ephemeral ports of 49152 to 65535. Running netstat showed that around 5-6k ports were being used during tests, so in theory there should have been many more available. If the lack of ports was indeed the cause of the exceptions it means that either netstat didn&#39;t properly report the situation or HttClient only uses a maximum number of ports after which it starts throwing exceptions.

By contrast, the multithread approach of generating HTTP calls behaved very predictable. I took it around 0.6 seconds for 10k messages, around 5.5 seconds for 100k messages and as expected around 55 seconds for 1 million messages. None of the messages failed. Further more, while it ran, it never used more than 55 MB of RAM (according to Windows Task Manager). The memory used when sending messages asynchronously grew proportionally with the load. It used around 500 MB of RAM during the 200k messages tests.

I think there are two main reasons for the above results. The first one is that HttpClient seems to be very greedy in creating new connections with the server. The high number of used ports reported by netstat means that it probably doesn&#39;t benefit much from HTTP keep-alive.

The second is that HttpClient doesn&#39;t seem to have a throttling mechanism. In fact this seems to be a general problem related to async operations. If you need to perform a very large number of operations they will all be started at once and then their continuations will be executed as they are available. In theory this should be ok, because in async operations the load is on external systems but as proved above this is not entirely the case. Having a big number of requests started at once will increase the memory usage and slow down the entire execution.

I managed to obtain better results, memory and execution time wise, by limiting the maximum number of asynchronous requests with a simple but primitive delay mechanism:

    public async void TestAsyncWithDelay()
    {
    	this.TestInit();
    	HttpClient httpClient = new HttpClient();
    
    	for (int i = 0; i &lt; NUMBER_OF_REQUESTS; i++)
    	{
    		if (_activeRequestsCount &gt;= MAX_CONCURENT_REQUESTS)
    			await Task.Delay(DELAY_TIME);
    
    		ProcessUrlAsyncWithReqCount(httpClient);
    	}
    }

It would be really useful if HttpClient included a mechanism for limiting the number of concurrent requests. When using the Task class (which is based on the .Net thread pool) throttling is automatically achieved by limiting the number of concurrent threads.

For a complete overview, I have also created a version of the async test based on HttpWebRequest rather than HttpClient and managed to obtain much better results. For a start, it allows setting a limit on the number of concurrent connections (with ServicePointManager.DefaultConnectionLimit or via config), which means that it never ran out of ports and never failed on any request (HttpClient, by default, is based on HttpWebRequest, but it seems to ignore the connection limit setting).

The async HttpWebRequest approach was still about 50 - 60% slower than the multithreading one, but it was predictable and reliable. The only downside to it was that it used a huge amount of memory under big load. For example it needed around 1.6 GB for sending 1 million requests. By limiting the number of concurrent requests (like I did above for HttpClient) I managed to reduce the used memory to just 20 MB and obtain an execution time just 10% slower than the multithreading approach.

After this lengthy presentation, my questions are: Is the HttpClient class from .Net 4.5 a bad choice for intensive load applications? Is there any way to throttle it, which should fix the problems I mention about? How about the async flavor of HttpWebRequest?

**Update (thanks @Stephen Cleary)**

As it turns out, HttpClient, just like HttpWebRequest (on which it is based by default), can have its number of concurrent connections on the same host limited with ServicePointManager.DefaultConnectionLimit. The strange thing is that according to [MSDN](http://msdn.microsoft.com/en-us/library/system.net.servicepointmanager.defaultconnectionlimit.aspx), the default value for the connection limit is 2. I also checked that on my side using the debugger which pointed that indeed 2 is the default value. However, it seems that unless explicitly setting a value to ServicePointManager.DefaultConnectionLimit, the default value will be ignored. Since I didn&#39;t explicitly set a value for it during my HttpClient tests I thought it was ignored.

After setting ServicePointManager.DefaultConnectionLimit to 100 HttpClient became reliable and predictable (netstat confirms that only 100 ports are used). It is still slower than async HttpWebRequest (by about 40%), but strangely, it uses less memory. For the test which involves 1 million requests, it used a maximum of 550 MB, compared to 1.6 GB in the async HttpWebRequest.

So, while HttpClient in combination ServicePointManager.DefaultConnectionLimit seem to ensure reliability (at least for the scenario where all the calls are being made towards the same host), it still looks like its performance is negatively impacted by the lack of a proper throttling mechanism. Something that would limit the concurrent number of requests to a configurable value and put the rest in a queue would make it much more suitable for high scalability scenarios.

Is async HttpClient from .Net 4.5 a bad choice for intensive load applications?

I have the following query

    SELECT * FROM table
    WHERE tester &lt;&gt; &#39;username&#39;;

I am expecting this to return all the results where tester is not the string `username`, But this not working. I think I am looking for the inverse of the `Like` operator but I am not sure? In my searches I have found solutions for numbers (that&#39;s where i got &lt;&gt; from), but this seems to not be working with strings. 

SQL: How to perform string does not equal

I have the following query
<pre><code class="hljs language-sql">SELECT * FROM table
WHERE tester &#x3C;> 'username';
</code></pre>
I am expecting this to return all the results where tester is not the string <code>username</code>, But this not working. I think I am looking for the inverse of the <code>Like</code> operator but I am not sure? In my searches I have found solutions for numbers (that's where i got &#x3C;> from), but this seems to not be working with strings.

When I attempted to connect to a local MySQL server during my test suite, it
fails with the error:

    OperationalError: (2002, &quot;Can&#39;t connect to local MySQL server through socket &#39;/tmp/mysql.sock&#39; (2)&quot;)

However, I&#39;m able to at all times, connect to MySQL by running the command line
``mysql`` program. A ``ps aux | grep mysql`` shows the server is running, and
``stat /tmp/mysql.sock`` confirm that the socket exists. Further, if I open a
debugger in ``except`` clause of that exception, I&#39;m able to reliably connect
with the exact same parameters.

This issue reproduces fairly reliably, however it doesn&#39;t appear to be 100%,
because every once in a blue moon, my test suite does in fact run without
hitting this error. When I attempted to run with ``sudo dtruss`` it did not reproduce.

All the client code is in Python, though I can&#39;t figure how that&#39;d be relevant.

Switching to use host ``127.0.0.1`` produces the error:

    DatabaseError: Can&#39;t connect to MySQL server on &#39;127.0.0.1&#39; (61)


Can&#39;t connect to local MySQL server through socket &#39;/tmp/mysql.sock

What is maximum query size for mysql? Some times the server stops working when I fire a too long query.


What is maximum query size for mysql?

I have an insert query (active record style) used to insert the form fields into a MySQL table. I want to get the last auto-incremented id for the insert operation as the return value of my query but I have some problems with it.

Inside the controller:

    function add_post(){
		$post_data = array(
			&#39;id&#39;			=&gt; &#39;&#39;,
			&#39;user_id&#39;	=&gt;	&#39;11330&#39;,
			&#39;content&#39;	=&gt;	$this-&gt;input-&gt;post(&#39;poster_textarea&#39;),
			&#39;date_time&#39;	=&gt; date(&quot;Y-m-d H:i:s&quot;),
			&#39;status&#39;		=&gt;	&#39;1&#39;
		);
		return $this-&gt;blog_model-&gt;add_post($post_data);
	}
And inside model:

    function add_post($post_data){
	    $this-&gt;db-&gt;trans_start();
	    $this-&gt;db-&gt;insert(&#39;posts&#39;,$post_data);
	    $this-&gt;db-&gt;trans_complete();
	    return $this-&gt;db-&gt;insert_id();
	}
I get nothing as the return of the add_post in model

how to get last insert id after insert query in codeigniter active record

I&#39;m in the process of moving my files onto another computer, and one thing I would like to do is to transfer the data in my MySQL database. I want to dump the databases into .sql files, but also have the create database db_name including in the file, that way I just have to import the file to mysql without having to manually create the databases. Is there a way to do that?

mysqldump with create database line

I want to run a set of queries to insert some data into an SQL table but only if the record satisfying certain criteria are met. The table has 4 fields: `id` (primary), `fund_id`, `date` and `price`

I have 3 fields in the query: `fund_id`, `date` and `price`.

So my query would go something like this:

    INSERT INTO funds (fund_id, date, price)
        VALUES (23, &#39;2013-02-12&#39;, 22.43)
        WHERE NOT EXISTS (
           SELECT * 
           FROM funds 
           WHERE fund_id = 23
             AND date = &#39;2013-02-12&#39;
        );

So I only want to insert the data if a record matching the `fund_id` and `date` does not already exist. If the above is correct it strikes me as quite an inefficient way of achieving this as an additional select statement must be run each time.

Is there a better way of achieving the above?

Edit: For clarification neither `fund_id` nor `date` are unique fields; records sharing the same fund_id or date will exist but no record should have both the same fund_id and date as another.

Content Type	Original Author	Original Content on Stackoverflow
Question	Dan Ciborowski - MSFT	View Question on Stackoverflow
Solution 1 - Mysql	Gordon Linoff	View Answer on Stackoverflow
Solution 2 - Mysql	Chris	View Answer on Stackoverflow
Solution 3 - Mysql	Viktor Zeman	View Answer on Stackoverflow
Solution 4 - Mysql	Ömer Faruk Almalı	View Answer on Stackoverflow
Solution 5 - Mysql	user3088463	View Answer on Stackoverflow
Solution 6 - Mysql	karthik kasubha	View Answer on Stackoverflow

SQL: How to perform string does not equal

Mysql Problem Overview

Mysql Solutions

Solution 1 - Mysql

Solution 2 - Mysql

Solution 3 - Mysql

Solution 4 - Mysql

Solution 5 - Mysql

Solution 6 - Mysql

Is async HttpClient from .Net 4.5 a bad choice for intensive load applications?

Does .asSet(...) exist in any API?

Attributions