Just leave most of the sounds away, and there is not much left. This is a funny, yet creepy mash-up of a 1964 Rolling Stones concert. We prefer the actual one, with music. By a […]
The post When You Mute The Music The Rolling Stones Become Kind Of Creepy appeared first on Viral Viral Videos.
While the news is a serious setting, there do happen some seriously funny things every now and then. Every correspondent has to do some improvisation, which proves to be a very good resource for comedy. […]
The post The News Isn’t Always As Serious As You Would Expect appeared first on Viral Viral Videos.
Just a couple more hours until April Fools’ Day hit. Please be extra careful, and why wouldn’t you pull off a stunt or two yourself? This video guides you through the do’s and don’ts. Have […]
The post April Fools Is Upon Us: Learn How To Prank appeared first on Viral Viral Videos.
Candids of model Dayane Mello bending over and slipping an areola outside a clothing store in Milan! She then goes in and tries on some dresses. View the pictures
Okay, ladies and gentlemen, time for some educational content. Remember the medieval ages? No, you weren’t born then, probably… We want to focus for five minutes on the long forgotten meaning of snails back then. […]
The post Why Knights Fought Snails In Medieval Art appeared first on Viral Viral Videos.
Candids of a braless Bella Hadid in leather pants and a red top while out and about in New York! View the pictures
You could use classical music to relax to, and some candy to… Well, you eat it while you relax or something. Or when you’re hungry or depressed, but that’s another story entirely. This guy decided […]
The post Classical Music And Your Average Candy: A Killer Combo appeared first on Viral Viral Videos.
"I have a feeling that VS Code is trying to tell me that the object class provides functionality common to all JavaScript objects," writes Eric.
"Hmmm...When I set out to upgrade my broadband speed, 'null' wasn't quite what I had in mind," writes Michael R.
"All I wanted to know was how far sound travels in 15 milliseconds," Andreas wrote, "I didn't realize that I would need to take the wheelbase of a Mitsubishi Galant into account."
Martin wrote, "I think they must be targeting a younger demographic who will be around for the 2083 issue."
"Do you want a Skynet apocalypse? Because this how you get a Skynet apocalypse," Jeff H. wrote.
"Seems my VPN provider knows when to cancel my lifetime subscription in advance. Do they know something that I don't?" writes Niels.
Pascal wrote, "This message doesn't not confuse me greatly."
[Advertisement] Scale your release pipelines, creating secure, reliable, reusable deployments with one click. Download and learn more today!
Rocky Barnes also known as Rachel Barnes is an Instagram model with close to one million followers. Here she is at the beach in Miami and I think she's hot and I also like those pokies. View the pictures
You think you’re going for a casual talk, when the woman starts putting on a strange but familiar voice. The voice of your midnight The Simpsons binge-watching sessions. She is pretty good, we must admit…
The post The Surprise When You Meet Bart Simpson In Real Life appeared first on Viral Viral Videos.
Bella Hadid posed for Wonderland magazine and its a pretty boring spread except for one shot! We can see her titty in that shot. View the pictures
Candids of Brooke Burke getting wet in a swimsuit at the beach in St. Barts! Wetness definitely turns the top half of her swimsuit into a see through one! View the pictures
Social Security Cards don’t seem like the most engaging of topics, but it is an important one. Why, for example, does practically the whole world own a personal ID card, except for the United States […]
The post Social Security Cards Explained appeared first on Viral Viral Videos.
This cute little girl doesn’t seem concerned at all about the progression of Artificial Intelligence. She embraces every new visitor of her street, beating heart or not. The “robot” seems a little underwhelmed though…
The post When AI Is Taking Over The Neighborhood appeared first on Viral Viral Videos.
Hikari had just left Apps R' Us when our submitter, Steve, was asked by the CEO to review some of his code. Now, Steve wasn't on the same project as Hikari, but he had a reputation for being thorough and concise, while Hikari had a reputation for being fast but sloppy. Apps R' Us was a smallish shop, so Steve was a good pick for taking over the project despite barely knowing the requirements.
Hikari was working on an augmented reality game for a very specific problem domain. In this use case, GPS was going to be unreliable. Instead, they needed to focus on the compass heading and rough location most times, at most correcting a little from GPS data. Steve skimmed through the code, looking for the overall structure before he dove into the fine details, but the following comment stopped him in his tracks:
// The bluetooth manager and location manager must be initialized at app launch
// There must be a delay between initialisation and checking whether bluetooth/location
// services are available as the manager will ALWAYS say that it is unavailble at the point
// of initialisation as it hasn't yet had chance to properly determine the status
Huh? Steve thought to himself. Weird. Why do I have to handle that in the app code? Shouldn't the manager class have a state machine that can check on this? And why are there so many typos anyway?
He moved to the LocationManager to take a look at what that code was doing so he could understand what made a state machine a poor choice. And that's when he found this particular beauty:
- (BOOL)_locationIsAccurate:(CLLocation *)location
{
// The vertical and horizontal accurancy at its best tends to be at 3 and 5 respectively.
// As such combining both values, dividing by 2 and checking if the value is <= 10,
// should be a good indicator that the person is outside with a good, clear signal,
return (((location.horizontalAccuracy + location.verticalAccuracy) / 2) <= 20);
}
Problem one: the code doesn't match the comment; it compares the value to 20, not 10. Problem two: the comment makes no sense. What's going on? Are you subtracting the 3 from the 5 to get 2? Or is this an average? Assuming it's an average, why does the average being under 10 (or 20) mean "good signal?"
Wait ... good signal from the GPS? The GPS we're not using? Understanding dawned on Steve, and he checked for places the code was called.
The GPS was polled for location data, at best possible accuracy, once a second. The result, however, was checked for accuracy and then promptly disregarded on every single call.
There wasn't any use for this function at all.
Steve jumped away from his desk and swung over to his manager's office. "So, boss, I think I can save everyone's battery life in the next update ..."
[Advertisement] BuildMaster integrates with an ever-growing list of tools to automate and facilitate everything from continuous integration to database change scripts to production deployments. Interested? Learn more about BuildMaster!
Chrissy Teigen didn't wear a bra while attending the H&M Conscious Exclusive Collection Dinner in Los Angeles last night. No wardrobe malfunctions but definitely some nice cleavage and pokies. View the pictures
People are awesome. Prepare for a very slick montage of the most insane extreme sports, ludicrous acrobatics and much more impressive footage showing what we humans are capable of.
The post Need Some Good Feels? Watch How Awesome We Humans Are appeared first on Viral Viral Videos.
Sexy outtakes of Christina Milian posing for a Maxim photo shoot! The see through shot is obviously the highlight. Can't wait for an HQ version. View the pictures
Candids of Argentine model and actress Karina Jelinek flashing her boobs at the beach in Miami! Love foreign celebs. View the pictures
The Slow Mo guys are known for, well, slow motion videos, and they are extremely gorgeous. You can almost feel the temperature rise, you hear the noise build and there it goes. The most perfect […]
The post The Slow Mo Guys Are Back With Incredible Footage Of A Rocket’s Launch appeared first on Viral Viral Videos.
We bet everyone gets upset now and then about some silly rule or law they never knew existed. We sure do. But we must admit it’s a small inconvenience compared to these weird laws. We’d […]
The post That Silly Law In Your Country? It’s Nothing Compared To This appeared first on Viral Viral Videos.
Usul is taking a college course on Java programming, and it’s doing an excellent job preparing him for the real world. Already, he’s been forced to cope with someone who knows one true fact and has run off to apply it in the dumbest way possible. This would be his professor.
Our true fact is this: A Java PreparedStament object, used for running database queries, should be closed after use. This returns its connection to the pool and frees any resources the statement was using. You should do this, and you should do it as soon as you’re done with your connection.
Now, putting a call to stmt.close() in every finally block was just too much for Professor McCloseypants to deal with. So he provided this “convenience” object to deal with that problem.
It’s a lot of code, so we’re going to do this in pieces. First, let’s look at the declaration:
public class ClosingPreparedStatement {
…
}
Now, remember, the purpose of this class is to do everything a PreparedStatement does, but add a self-closing behavior. Thus, the first problem here is that it doesn’t have an extends or implements declaration, so that it could share a common interface with PreparedStatements.
/**
*
*/
public static boolean somethingFinalized = false;
Remember, this is a professor, providing this code as a model of what his students should be doing. For the capstone course, required for graduation.
Now, this is a wrapper around a PreparedStatement, so guess how most of the methods work…
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param arg1 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int executeUpdate(String arg0, String[] arg1) throws SQLException
{
return stmt.executeUpdate(arg0, arg1);
}
Oh yeah. There are almost 1,300 lines of code in this file, and yes, they’re pretty much all like this. So, with all of that, how does this magical self-closing statement work?
/**
* Closes the internal statement and delegates
*
* @throws Throwable if the delegate throws it
*/
protected void finalize() throws Throwable
{
try
{
stmt.close();
somethingFinalized = true;
} finally
{
super.finalize();
}
}
He put it in the finalize method. If you’re not intimate with Java’s memory management, keep in mind: the finalize method is called by the garbage collector when it finally cleans up memory. You have no guarantees about when that will happen, or even if it ever well. So much for the “as soon as you’re done”.
Here is all 1,300ish lines of the file, in all its delegatory glory:
package datasource;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
/**
* This Prepared statement will always finalized itself to make sure that
* everything gets cleaned up.
*/
public class ClosingPreparedStatement
{
/**
*
*/
public static boolean somethingFinalized = false;
private PreparedStatement stmt;
/**
* @param connection the connection
* @param sql the sql for this statement
* @throws SQLException if the prepared statement it contains throws an
* exception
*/
public ClosingPreparedStatement(Connection connection, String sql) throws SQLException
{
stmt = connection.prepareStatement(sql);
}
/**
*
* @param connection the connection we should use
* @param sql the statement we will execute
* @param autoGeneratedKeys the keys
* @throws SQLException if we can't create the statement
*/
public ClosingPreparedStatement(Connection connection, String sql, int autoGeneratedKeys) throws SQLException
{
stmt = connection.prepareStatement(sql, autoGeneratedKeys);
}
/**
* Just delegates
*
* @throws SQLException if delegated call throws it
*/
public void addBatch() throws SQLException
{
stmt.addBatch();
}
/**
* Just delegates
*
* @param arg0 delegate
* @throws SQLException if delegated call throws it
*/
public void addBatch(String arg0) throws SQLException
{
stmt.addBatch(arg0);
}
/**
* Just delegates
*
* @throws SQLException if delegated call throws it
*/
public void cancel() throws SQLException
{
stmt.cancel();
}
/**
* Just delegates
*
* @throws SQLException if delegate throws it
*/
public void clearBatch() throws SQLException
{
stmt.clearBatch();
}
/**
* Just delegates
*
* @throws SQLException if delegate throws it
*/
public void clearParameters() throws SQLException
{
stmt.clearParameters();
}
/**
* Just delegates
*
* @throws SQLException if delegate throws it
*/
public void clearWarnings() throws SQLException
{
stmt.clearWarnings();
}
/**
* Just delegates
*
* @throws SQLException if delegate throws it
*/
public void close() throws SQLException
{
stmt.close();
}
/**
* Just delegates
*
* @throws SQLException if delegate throws it
*/
public void closeOnCompletion() throws SQLException
{
stmt.closeOnCompletion();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean execute() throws SQLException
{
return stmt.execute();
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @return the delgate's return value
* @throws SQLException if delegate throws it
*/
public boolean execute(String arg0) throws SQLException
{
return stmt.execute(arg0);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param arg1 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean execute(String arg0, int arg1) throws SQLException
{
return stmt.execute(arg0, arg1);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param arg1 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean execute(String arg0, int[] arg1) throws SQLException
{
return stmt.execute(arg0, arg1);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param arg1 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean execute(String arg0, String[] arg1) throws SQLException
{
return stmt.execute(arg0, arg1);
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int[] executeBatch() throws SQLException
{
return stmt.executeBatch();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public ResultSet executeQuery() throws SQLException
{
return stmt.executeQuery();
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public ResultSet executeQuery(String arg0) throws SQLException
{
return stmt.executeQuery(arg0);
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int executeUpdate() throws SQLException
{
return stmt.executeUpdate();
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int executeUpdate(String arg0) throws SQLException
{
return stmt.executeUpdate(arg0);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param arg1 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int executeUpdate(String arg0, int arg1) throws SQLException
{
return stmt.executeUpdate(arg0, arg1);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param arg1 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int executeUpdate(String arg0, int[] arg1) throws SQLException
{
return stmt.executeUpdate(arg0, arg1);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param arg1 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int executeUpdate(String arg0, String[] arg1) throws SQLException
{
return stmt.executeUpdate(arg0, arg1);
}
/**
* Closes the internal statement and delegates
*
* @throws Throwable if the delegate throws it
*/
protected void finalize() throws Throwable
{
try
{
stmt.close();
somethingFinalized = true;
} finally
{
super.finalize();
}
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public java.sql.Connection getConnection() throws SQLException
{
return stmt.getConnection();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getFetchDirection() throws SQLException
{
return stmt.getFetchDirection();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getFetchSize() throws SQLException
{
return stmt.getFetchSize();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public ResultSet getGeneratedKeys() throws SQLException
{
return stmt.getGeneratedKeys();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getMaxFieldSize() throws SQLException
{
return stmt.getMaxFieldSize();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getMaxRows() throws SQLException
{
return stmt.getMaxRows();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public ResultSetMetaData getMetaData() throws SQLException
{
return stmt.getMetaData();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean getMoreResults() throws SQLException
{
return stmt.getMoreResults();
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean getMoreResults(int arg0) throws SQLException
{
return stmt.getMoreResults(arg0);
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public ParameterMetaData getParameterMetaData() throws SQLException
{
return stmt.getParameterMetaData();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getQueryTimeout() throws SQLException
{
return stmt.getQueryTimeout();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public ResultSet getResultSet() throws SQLException
{
return stmt.getResultSet();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getResultSetConcurrency() throws SQLException
{
return stmt.getResultSetConcurrency();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getResultSetHoldability() throws SQLException
{
return stmt.getResultSetHoldability();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getResultSetType() throws SQLException
{
return stmt.getResultSetType();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public int getUpdateCount() throws SQLException
{
return stmt.getUpdateCount();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public SQLWarning getWarnings() throws SQLException
{
return stmt.getWarnings();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean isClosed() throws SQLException
{
return stmt.isClosed();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean isCloseOnCompletion() throws SQLException
{
return stmt.isCloseOnCompletion();
}
/**
* Just delegates
*
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean isPoolable() throws SQLException
{
return stmt.isPoolable();
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @return the delegates return value
* @throws SQLException if delegate throws it
*/
public boolean isWrapperFor(Class<?> arg0) throws SQLException
{
return stmt.isWrapperFor(arg0);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setArray(int parameterIndex, Array x) throws SQLException
{
stmt.setArray(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException
{
stmt.setAsciiStream(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException
{
stmt.setAsciiStream(parameterIndex, x, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException
{
stmt.setAsciiStream(parameterIndex, x, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException
{
stmt.setBigDecimal(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException
{
stmt.setBinaryStream(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException
{
stmt.setBinaryStream(parameterIndex, x, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException
{
stmt.setBinaryStream(parameterIndex, x, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBlob(int parameterIndex, Blob x) throws SQLException
{
stmt.setBlob(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param inputStream delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException
{
stmt.setBlob(parameterIndex, inputStream);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param inputStream delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException
{
stmt.setBlob(parameterIndex, inputStream, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBoolean(int parameterIndex, boolean x) throws SQLException
{
stmt.setBoolean(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setByte(int parameterIndex, byte x) throws SQLException
{
stmt.setByte(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setBytes(int parameterIndex, byte[] x) throws SQLException
{
stmt.setBytes(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param reader delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException
{
stmt.setCharacterStream(parameterIndex, reader);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param reader delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException
{
stmt.setCharacterStream(parameterIndex, reader, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param reader delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException
{
stmt.setCharacterStream(parameterIndex, reader, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setClob(int parameterIndex, Clob x) throws SQLException
{
stmt.setClob(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param reader delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setClob(int parameterIndex, Reader reader) throws SQLException
{
stmt.setClob(parameterIndex, reader);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param reader delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setClob(int parameterIndex, Reader reader, long length) throws SQLException
{
stmt.setClob(parameterIndex, reader, length);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setCursorName(String arg0) throws SQLException
{
stmt.setCursorName(arg0);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setDate(int parameterIndex, Date x) throws SQLException
{
stmt.setDate(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param cal delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException
{
stmt.setDate(parameterIndex, x, cal);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setDouble(int parameterIndex, double x) throws SQLException
{
stmt.setDouble(parameterIndex, x);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setEscapeProcessing(boolean arg0) throws SQLException
{
stmt.setEscapeProcessing(arg0);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setFetchDirection(int arg0) throws SQLException
{
stmt.setFetchDirection(arg0);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setFetchSize(int arg0) throws SQLException
{
stmt.setFetchSize(arg0);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setFloat(int parameterIndex, float x) throws SQLException
{
stmt.setFloat(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setInt(int parameterIndex, int x) throws SQLException
{
stmt.setInt(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setLong(int parameterIndex, long x) throws SQLException
{
stmt.setLong(parameterIndex, x);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setMaxFieldSize(int arg0) throws SQLException
{
stmt.setMaxFieldSize(arg0);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setMaxRows(int arg0) throws SQLException
{
stmt.setMaxRows(arg0);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param value delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException
{
stmt.setNCharacterStream(parameterIndex, value);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param value delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException
{
stmt.setNCharacterStream(parameterIndex, value, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param value delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNClob(int parameterIndex, NClob value) throws SQLException
{
stmt.setNClob(parameterIndex, value);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param reader delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNClob(int parameterIndex, Reader reader) throws SQLException
{
stmt.setNClob(parameterIndex, reader);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param reader delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException
{
stmt.setNClob(parameterIndex, reader, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param value delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNString(int parameterIndex, String value) throws SQLException
{
stmt.setNString(parameterIndex, value);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param sqlType delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNull(int parameterIndex, int sqlType) throws SQLException
{
stmt.setNull(parameterIndex, sqlType);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param sqlType delegate's parameter
* @param typeName delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException
{
stmt.setNull(parameterIndex, sqlType, typeName);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setObject(int parameterIndex, Object x) throws SQLException
{
stmt.setObject(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param targetSqlType delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException
{
stmt.setObject(parameterIndex, x, targetSqlType);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param targetSqlType delegate's parameter
* @param scaleOrLength delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException
{
stmt.setObject(parameterIndex, x, targetSqlType, scaleOrLength);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setPoolable(boolean arg0) throws SQLException
{
stmt.setPoolable(arg0);
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setQueryTimeout(int arg0) throws SQLException
{
stmt.setQueryTimeout(arg0);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setRef(int parameterIndex, Ref x) throws SQLException
{
stmt.setRef(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setRowId(int parameterIndex, RowId x) throws SQLException
{
stmt.setRowId(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setShort(int parameterIndex, short x) throws SQLException
{
stmt.setShort(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param xmlObject delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException
{
stmt.setSQLXML(parameterIndex, xmlObject);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setString(int parameterIndex, String x) throws SQLException
{
stmt.setString(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setTime(int parameterIndex, Time x) throws SQLException
{
stmt.setTime(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param cal delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException
{
stmt.setTime(parameterIndex, x, cal);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException
{
stmt.setTimestamp(parameterIndex, x);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param cal delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException
{
stmt.setTimestamp(parameterIndex, x, cal);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @param length delegate's parameter
* @throws SQLException if delegate throws it
*
*/
@Deprecated
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException
{
stmt.setUnicodeStream(parameterIndex, x, length);
}
/**
* Just delegates
*
* @param parameterIndex delegate's parameter
* @param x delegate's parameter
* @throws SQLException if delegate throws it
*/
public void setURL(int parameterIndex, URL x) throws SQLException
{
stmt.setURL(parameterIndex, x);
}
/**
* @see java.lang.Object#toString()
*/
public String toString()
{
return stmt.toString();
}
/**
* Just delegates
*
* @param arg0 delegate's parameter
* @param <T> delegate's parameter
* @return delegate's return value
* @throws SQLException if delegate throws it
*/
public <T> T unwrap(Class<T> arg0) throws SQLException
{
return stmt.unwrap(arg0);
}
}
[Advertisement] Application Release Automation for DevOps – integrating with best of breed development tools. Free for teams with up to 5 users. Download and learn more today!
You never know when those handcrafting skills come in handy (no pun intended). Please pay great attention to this ingenious guy and take notes. It might save your life some day.
The post Be Prepared For The Apocalypse: Use Primitive Technology In Your Advantage appeared first on Viral Viral Videos.
Remi Gaillard, you either hate him or love him. We tend to do the latter, but must admit there is a thin line between being funny and just being annoying. He pulls off some cheesy […]
The post Remi Gaillard Is Messing With Everyday People Again appeared first on Viral Viral Videos.
Kendall Jenner is pretending to be Marilyn Monroe in this video for Love magazine! She's clearly wearing a see through bra in a bunch of the shots. View the video + caps
Legendary swimsuit model Angie Everhart walked the red carpet in a see through dress at the 8th Annual Unstoppable Foundation Gala in Beverly Hills! Still looks good! View the pictures
Unfortunately, Nirvana is long gone. We don’t like it, you don’t like it and kids today don’t even know what they’ve missed out on. Or do they? They are hilariously honest after hearing some of their […]
The post The World Would Be A Different Place If Today’s Kids Knew Nirvana appeared first on Viral Viral Videos.
Malin Akerman flashed her boobs on the latest episode of Billions! I've been wanting to watch this show and this tit might just be what gets me to do it. View the pictures + GIF
If you don’t miss the Ducktales–there’s the door. We go to great lengths to find anything that reminds us of their great adventures. This odd mixture of furry creatures give the famous theme song their […]
The post This Animal Coverband Gives The Ducktales Theme Song Their Best Shot appeared first on Viral Viral Videos.
And Gordon Ramsey is not someone to take ungratefulness or unsolicited criticism lightly. Enjoy the fireworks!
The post This Makeover Produces Nothing But Smiles, Until The Owner Opens Her Mouth appeared first on Viral Viral Videos.
David was recently hired on to head the company’s development team. This was a brand-new position; previously, William, the company’s IT Manager managed the developers directly in addition to his other duties.
While getting his workstation set up, he was unable to install the FileZilla FTP client. It was completely blocked via domain policy. Finding this very strange, David talked to the IT Manager and hoped there was a legitimate reason.
“FTP is a big security risk,” William explained. “We got hacked through FTP once so I firewalled it by blocking FileZilla installation with Group Policy.” David began to suspect that things at the company were not quite right.
“Um, Group Policy isn’t a firewall,” David tried to explain. “And blocking an FTP client installer is unlikely to have an effect on network security.”
William clearly didn’t understand and doubled down on his incorrect ideas. “Trust me, it works,” he said. David soon gave up and simply installed a different FTP client–which worked just fine despite FTP being “firewalled.”
Later, while familiarizing himself with the business’s core applications, David decided to examine the company’s main database server. “It’s set up with RAID 10 for the best performance,” William explained. RAID 10, sometimes called RAID 1+0, mirrors all data into two arrays for fault tolerance, and then each array is striped onto additional disks to greatly improve read/write performance. It’s one of the fastest RAID configurations and a great fit for database servers.
But David ran a disk benchmark and was not convinced. “That disk I/O is way too low for RAID 10,” he explained. “Can you show me the configuration?”
“Of course,” William replied. “It has to be RAID 10. We ordered it that way.”
They opened the RAID manager for the system, and sure enough the system was not running RAID 10. “Um, this is RAID 5,” David explained. RAID 5 uses three or more disks for striping, but the capacity of one disk is lost for storing parity data which allows the array’s data to survive a single-disk failure. Due to the required parity calculations, RAID 5 writes are not nearly as fast as RAID 10, which is bad for an I/O bound application such as the company’s main database server.
“That can’t be,” William responded. “Oh, I know…Kieran must have changed it!” He called the company’s so-called systems administrator to the room, and David endured the uncomfortable exchange as William hurled wild accusations. “I know we ordered this system with RAID 10! Why did you change it?”
“I just unboxed it and racked it,” Kieran responded. “Whatever RAID level it has is what it was shipped with.”
“That can’t be true! You tampered with it!”
Kieran rolled his eyes and turned to leave. “I have real work to do elsewhere,” he rudely explained as he excused himself from the conversation. Later on, he sent an email to both David and William which contained the original Purchase Order for the server. The PO clearly showed that William had specifically requested RAID 5 for the server.
David found himself wondering if management was aware of William’s behavior and general incompetence, but tried to avoid making waves during training. But the final straw came when he set about installing several of the company’s internal applications and was unable to find any installers on his own. Once again he went to talk to William.
“Oh, we don’t install any of our applications. That’s too slow!” he explained. “Instead, look at the database server. It has a shared folder called ‘APPS’, and just map that as a network drive and run everything from there.”
Once again, David found himself doubting the IT Manager’s wisdom. “Doesn’t it hurt our database performance to have the entire company mapping a network drive to the same RAID array as the databases?” he asked.
“Oh no,” he replied. “It actually makes it faster. The apps can talk to the database much faster if they’re running from the same server!”
David was stunned by William’s poor understanding of how network-mapped file systems actually work. “That might be true if it was a terminal server…but the applications still run locally on the end user PCs. The files just happen to be stored elsewhere.”
“What do you know, you’re still the new guy! We’ve had this procedure in place for years now, and for good reason!”
Despite being a newbie, David decided to approach management about the ineptness he’d discovered, and explained that William was rude, incompetent, and had no business working in IT. To his surprise, management conducted a brief investigation and agreed with him! Shortly afterwards, William was let go.
The new IT manager was shocked at the company’s infrastructure and quickly made a range of improvements. This included installing a proper Storage Area Network which greatly improved the database server’s performance; a new storage pool for mapped drives which was on separate disks than databases; and a real hardware firewall which, among other things, actually blocked incoming FTP connections from the Internet.
David then forwarded his story on to us at The Daily WTF as a reminder that sometimes things actually do turn out okay in the vast WTF-land that is the IT industry.
[Advertisement] Easily create complex server configurations and orchestrations using both the intuitive, drag-and-drop editor and the text/script editor. Find out more and download today!
When you’ve ever touch a basketball, you know a ton of stuff can go wrong. Which is why we never go near one (we’re better off behind our computer). But we do enjoy watching others […]
The post Basketball Makes For Some Excellent Fail Compilations appeared first on Viral Viral Videos.
Candids of well known Australian DJ Olivia Nervo losing her bikini top at the beach in Miami! She doesn't seem to mind too much though. View the pictures
Great candids of UFC ring girl Arianny Celeste caught topless at the beach in Mexico!! No idea who her topless friend but hey.. bonus boobs! View the pictures
There are no authentic people in commercials. Fact. But what if? This video shows you what would likely happen. You’d get a VERY honest set of opinions. Which the usual commercial companies probably want to […]
The post If The People In Commercials Were Actually Real People, And Not Actors appeared first on Viral Viral Videos.
We’re huge fan of the spicy wings series, and the questions and assignments they give their guests. Dax Shepard isn’t impressed and is his usual self, while the spiciness reaches abnormal heights…
The post This Dude Solves Insane Math Problems While Stuffing His Face With Spicy Wings appeared first on Viral Viral Videos.
Erika’s company wanted to implement this idea as a policy, so they set a limit on how many lines could be in a single method. The thinking was that if each method was short- say, under 100 lines- it would automatically be simple(r), right?
Well, Garret, down the hall, wrote a method that was three hundred lines long. During a code review, he was told to refactor it to simplify the logic and comply with the policy. So he did.
public void Update()
{
UpdateSection01();
UpdateSection02();
UpdateSection03();
}
[Advertisement] Release! is a light card game about software and the people who make it. Play with 2-5 people, or up to 10 with two copies - only $9.95 shipped!
You won’t be the only one chuckling away by someone else’s fails, and rightfully so. If you’re just being careless or craving some attention, it’s feels kind of sweet for something to go wrong. Exactly […]
The post When You Fail, You Might As Well Make A Grand Show Out Of It appeared first on Viral Viral Videos.
How would you react when you met The Pope? Millions of people would be jealous of such an opportunity, but this cute little girl took the chance to obtain the hat of her dreams. Idea […]
The post Stealing Inside The Vatican Is Obviously Illegal, But This Little Girl Almost Gets Away With It appeared first on Viral Viral Videos.
Don’t we all struggle sometimes with choices we made in the past? These college kids are slammed in their faces with their teen-selves, and are not ready for it. At all. From their posture to […]
The post These College Kids Cringe Hard When They Look Back At Their Teen Choices appeared first on Viral Viral Videos.
That dude from Casually Explained is at it again. He created some excellent steps to perform at a maximum level in this silly game called ‘Evolution III’, perhaps better known as life. Check the video […]
The post If Life Was A Game, This Is The Ultimate Walk-Through appeared first on Viral Viral Videos.
Ryan Reynolds and Jake Gyllenhaal are two of the best actors right now, and even in random interviews they give it their all. This video is very honest, very funny and unlike any other movie-interview […]
The post Ryan Reynolds And Jake Gyllenhaal Deal With Google’s Very Honest Autocomplete Function appeared first on Viral Viral Videos.
Of course, waiting sucks and traffic jams are the worst. But all you have to do to make everyone’s day even worse, is move your car Transformer-style and overtake them all being futuristic and shit. […]
The post Riding This Car Makes Everyone Instantly Think You’re A Douchebag appeared first on Viral Viral Videos.
America's Next Top Model star and actress Jessica Serfaty did some kind of a shoot with T-Mobile and she did it braless! View the pictures
British reality star Marnie Simpson posed for a shoot with UTan and Tone and there is a fantastic ass shot! The rest of the pics ain't bad either. View the pictures
Dogs and ponies are animals known to be great company for us humans, but did you know they are very fond of each other as well? They’re very cute playing together, and probably share a […]
The post Dogs And Ponies Are Not Only Human’s Friends, But Also Each Other’s appeared first on Viral Viral Videos.
Cheetahs are majestic as fuck, but best observed from a distance. This guy, however, doesn’t take ViralViralVideos’ advice too seriously (we can’t blame him), and goes for the close-up. He looks the large cat right […]
The post You Probably Aren’t Chilling Out When A Cheetah Jumps Into Your Car, Or Are You? appeared first on Viral Viral Videos.
Candids of Ashley Greene picking up groceries in Beverly Hills. Pretty normal stuff. Nice pokies though. View the pictures
Dreams are a way of your mind to process what happened during the day. Nightmares are the same, and while they often aren’t any fun or whatsoever at all, they can teach you a lot about […]
The post Nightmares Aren’t Funny At All, But You Might Learn Something Very Useful appeared first on Viral Viral Videos.
Mariah Carey went braless in a see through dress at Catch in West Hollywood last night! Great view of her nips. Gotta love how she's been flaunting that bod lately. View the pictures
Horses have feeling too, you know. When you’re up there and cursing and shouting and moaning all over the place, chances are you’re going to end up with your belly on the floor somewhere. That’s exactly […]
The post This Is The Loudest Horse Rider Of All Times And His Horse Just Had Enough appeared first on Viral Viral Videos.
"Wow! Those folks from null and undefined must be big fans! I mean, just look at that voting turnout!" Kayleigh wrote.
"Ah, Google News, you never fail to find the bugs in news sites' pages," wrote Paul B.
Geof writes, "Based on the reservation name, I hope that I won't be eating alone."
"Viber blocks 'null' friends because no one needs friends that are never there when you need them," Chizzy wrote.
"Thanks AT&T for the personalized video tour of, apparently, nobody's bill," writes Zach K.
Kevin L. writes, "So...will I have to hold the deposit, and null deposit to enter the lease?"
"Looks like little Bobby Tables signed up for an account with Vodafone NZ just before my mother tried to," wrote Peter G.
[Advertisement] Onsite, remote, bare-metal or cloud – create, configure and orchestrate 1,000s of servers, all from the same dashboard while continually monitoring for drift and allowing for instantaneous remediation. Download Otter today!
