//	sparse files      |     no |       yes |       yes
//
// The table's upper portion shows the [Header] fields, where each format reports
// the maximum number of bytes allowed for each string field and
// the integer type used to store each numeric field
// (where timestamps are stored as the number of seconds since the Unix epoch).
//
// The table's lower portion shows specialized features of each format,

	c.conn.got = append(c.conn.got, query)
	return c.Tx.ExecContext(ctx, query, args...)
}

func (c *wrapperTx) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
	c.conn.got = append(c.conn.got, query)
	return c.Tx.QueryContext(ctx, query, args...)
}

func (c *wrapperTx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {

yawned and shut his eyes.--`Tell her about the reason and all
that,' he said to the Gryphon.

  `The reason is,' said the Gryphon, `that they WOULD go with
the lobsters to the dance.  So they got thrown out to sea.  So
they had to fall a long way.  So they got their tails fast in
their mouths.  So they couldn't get them out again.  That's all.'

  `Thank you,' said Alice, `it's very interesting.  I never knew

	DB.Save(&User{Name: "select_with_variables"})

	rows, _ := DB.Table("users").Where("name = ?", "select_with_variables").Select("? as fake", gorm.Expr("name")).Rows()

	if !rows.Next() {
		t.Errorf("Should have returned at least one row")
	} else {
		columns, _ := rows.Columns()
		AssertEqual(t, columns, []string{"fake"})
	}

	rows.Close()
}

func TestSelectWithArrayInput(t *testing.T) {

    Iterator<String> filtered =
        filter(
            unfiltered,
            new Predicate<String>() {
              @Override
              public boolean apply(String s) {
                throw new AssertionFailedError("Should never be evaluated");
              }
            });

    List<String> expected = emptyList();
    List<String> actual = Lists.newArrayList(filtered);

					mode |= gorm.ScanUpdate
				}
			}

			rows, err := db.Statement.ConnPool.QueryContext(
				db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...,
			)
			if db.AddError(err) == nil {
				defer func() {
					db.AddError(rows.Close())
				}()
				gorm.Scan(rows, db, mode)

				if db.Statement.Result != nil {

        final String username = paramMap.get(CRAWLER_WEB_AUTH + "." + webAuthName + ".username");
        if (StringUtil.isEmpty(username)) {
            throw new CrawlerSystemException("username is empty. webAuth:" + webAuthName);
        }
        final String password = paramMap.get(CRAWLER_WEB_AUTH + "." + webAuthName + ".password");
        Credentials credentials;

                    ImmutableList.of("foo", "bar"),
                    new Function<String, String>() {
                      @Override
                      public String apply(String input) {
                        throw new IndexOutOfBoundsException();
                      }
                    })
                .toArray());
  }

  private static void assertTransformListIterator(List<String> list) {

      for (RoundingMode mode : modes) {
        Double previous = expectedValues.put(mode, expectedValue);
        if (previous != null) {
          throw new AssertionError();
        }
      }
      return this;
    }

    @CanIgnoreReturnValue
    RoundToDoubleTester roundUnnecessaryShouldThrow() {
      unnecessaryShouldThrow = true;

        try {
            return createProtwordsItem(this, form, hook);
        } catch (final ValidationErrorException e) {
            saveToken();
            throw e;
        }
    }

    /**
     * Get the protected word item.
     * @param action The action.
     * @param form The create form.
     * @param hook The error hook.