/external/javasqlite/src/main/java/SQLite/JDBC2z/JDBCPreparedStatement.java

https://gitlab.com/brian0218/rk3066_r-box_android4.2.2_sdk · Java · 967 lines · 821 code · 146 blank · 0 comment · 123 complexity · 89473aefaf705583b70ff6e44c183ed3 MD5 · raw file

  1. package SQLite.JDBC2z;
  2. import java.sql.*;
  3. import java.math.BigDecimal;
  4. import java.util.*;
  5. class BatchArg {
  6. String arg;
  7. boolean blob;
  8. BatchArg(String arg, boolean blob) {
  9. if (arg == null) {
  10. this.arg = null;
  11. } else {
  12. this.arg = new String(arg);
  13. }
  14. this.blob = blob;
  15. }
  16. }
  17. public class JDBCPreparedStatement extends JDBCStatement
  18. implements java.sql.PreparedStatement {
  19. private String sql;
  20. private String args[];
  21. private boolean blobs[];
  22. private ArrayList<BatchArg> batch;
  23. private static final boolean nullrepl =
  24. SQLite.Database.version().compareTo("2.5.0") < 0;
  25. public JDBCPreparedStatement(JDBCConnection conn, String sql) {
  26. super(conn);
  27. this.args = null;
  28. this.blobs = null;
  29. this.batch = null;
  30. this.sql = fixup(sql);
  31. }
  32. private String fixup(String sql) {
  33. StringBuffer sb = new StringBuffer();
  34. boolean inq = false;
  35. int nparm = 0;
  36. for (int i = 0; i < sql.length(); i++) {
  37. char c = sql.charAt(i);
  38. if (c == '\'') {
  39. if (inq) {
  40. char nextChar = 0;
  41. if(i + 1 < sql.length()) {
  42. nextChar = sql.charAt(i + 1);
  43. }
  44. if (nextChar == '\'') {
  45. sb.append(c);
  46. sb.append(nextChar);
  47. i++;
  48. } else {
  49. inq = false;
  50. sb.append(c);
  51. }
  52. } else {
  53. inq = true;
  54. sb.append(c);
  55. }
  56. } else if (c == '?') {
  57. if (inq) {
  58. sb.append(c);
  59. } else {
  60. ++nparm;
  61. sb.append(nullrepl ? "'%q'" : "%Q");
  62. }
  63. } else if (c == ';') {
  64. if (!inq) {
  65. break;
  66. }
  67. sb.append(c);
  68. } else if (c == '%') {
  69. sb.append("%%");
  70. } else {
  71. sb.append(c);
  72. }
  73. }
  74. args = new String[nparm];
  75. blobs = new boolean[nparm];
  76. try {
  77. clearParameters();
  78. } catch (SQLException e) {
  79. }
  80. return sb.toString();
  81. }
  82. private String fixup2(String sql) {
  83. if (!conn.db.is3()) {
  84. return sql;
  85. }
  86. StringBuffer sb = new StringBuffer();
  87. int parm = -1;
  88. for (int i = 0; i < sql.length(); i++) {
  89. char c = sql.charAt(i);
  90. if (c == '%') {
  91. sb.append(c);
  92. ++i;
  93. c = sql.charAt(i);
  94. if (c == 'Q') {
  95. parm++;
  96. if (blobs[parm]) {
  97. c = 's';
  98. }
  99. }
  100. }
  101. sb.append(c);
  102. }
  103. return sb.toString();
  104. }
  105. public ResultSet executeQuery() throws SQLException {
  106. return executeQuery(fixup2(sql), args, false);
  107. }
  108. public int executeUpdate() throws SQLException {
  109. executeQuery(fixup2(sql), args, true);
  110. return updcnt;
  111. }
  112. public void setNull(int parameterIndex, int sqlType) throws SQLException {
  113. if (parameterIndex < 1 || parameterIndex > args.length) {
  114. throw new SQLException("bad parameter index");
  115. }
  116. args[parameterIndex - 1] = nullrepl ? "" : null;
  117. blobs[parameterIndex - 1] = false;
  118. }
  119. public void setBoolean(int parameterIndex, boolean x)
  120. throws SQLException {
  121. if (parameterIndex < 1 || parameterIndex > args.length) {
  122. throw new SQLException("bad parameter index");
  123. }
  124. args[parameterIndex - 1] = x ? "1" : "0";
  125. blobs[parameterIndex - 1] = false;
  126. }
  127. public void setByte(int parameterIndex, byte x) throws SQLException {
  128. if (parameterIndex < 1 || parameterIndex > args.length) {
  129. throw new SQLException("bad parameter index");
  130. }
  131. args[parameterIndex - 1] = "" + x;
  132. blobs[parameterIndex - 1] = false;
  133. }
  134. public void setShort(int parameterIndex, short x) throws SQLException {
  135. if (parameterIndex < 1 || parameterIndex > args.length) {
  136. throw new SQLException("bad parameter index");
  137. }
  138. args[parameterIndex - 1] = "" + x;
  139. blobs[parameterIndex - 1] = false;
  140. }
  141. public void setInt(int parameterIndex, int x) throws SQLException {
  142. if (parameterIndex < 1 || parameterIndex > args.length) {
  143. throw new SQLException("bad parameter index");
  144. }
  145. args[parameterIndex - 1] = "" + x;
  146. blobs[parameterIndex - 1] = false;
  147. }
  148. public void setLong(int parameterIndex, long x) throws SQLException {
  149. if (parameterIndex < 1 || parameterIndex > args.length) {
  150. throw new SQLException("bad parameter index");
  151. }
  152. args[parameterIndex - 1] = "" + x;
  153. blobs[parameterIndex - 1] = false;
  154. }
  155. public void setFloat(int parameterIndex, float x) throws SQLException {
  156. if (parameterIndex < 1 || parameterIndex > args.length) {
  157. throw new SQLException("bad parameter index");
  158. }
  159. args[parameterIndex - 1] = "" + x;
  160. blobs[parameterIndex - 1] = false;
  161. }
  162. public void setDouble(int parameterIndex, double x) throws SQLException {
  163. if (parameterIndex < 1 || parameterIndex > args.length) {
  164. throw new SQLException("bad parameter index");
  165. }
  166. args[parameterIndex - 1] = "" + x;
  167. blobs[parameterIndex - 1] = false;
  168. }
  169. public void setBigDecimal(int parameterIndex, BigDecimal x)
  170. throws SQLException {
  171. if (parameterIndex < 1 || parameterIndex > args.length) {
  172. throw new SQLException("bad parameter index");
  173. }
  174. if (x == null) {
  175. args[parameterIndex - 1] = nullrepl ? "" : null;
  176. } else {
  177. args[parameterIndex - 1] = "" + x;
  178. }
  179. blobs[parameterIndex - 1] = false;
  180. }
  181. public void setString(int parameterIndex, String x) throws SQLException {
  182. if (parameterIndex < 1 || parameterIndex > args.length) {
  183. throw new SQLException("bad parameter index");
  184. }
  185. if (x == null) {
  186. args[parameterIndex - 1] = nullrepl ? "" : null;
  187. } else {
  188. args[parameterIndex - 1] = x;
  189. }
  190. blobs[parameterIndex - 1] = false;
  191. }
  192. public void setBytes(int parameterIndex, byte x[]) throws SQLException {
  193. if (parameterIndex < 1 || parameterIndex > args.length) {
  194. throw new SQLException("bad parameter index");
  195. }
  196. blobs[parameterIndex - 1] = false;
  197. if (x == null) {
  198. args[parameterIndex - 1] = nullrepl ? "" : null;
  199. } else {
  200. if (conn.db.is3()) {
  201. args[parameterIndex - 1] = SQLite.StringEncoder.encodeX(x);
  202. blobs[parameterIndex - 1] = true;
  203. } else {
  204. args[parameterIndex - 1] = SQLite.StringEncoder.encode(x);
  205. }
  206. }
  207. }
  208. public void setDate(int parameterIndex, java.sql.Date x)
  209. throws SQLException {
  210. if (parameterIndex < 1 || parameterIndex > args.length) {
  211. throw new SQLException("bad parameter index");
  212. }
  213. if (x == null) {
  214. args[parameterIndex - 1] = nullrepl ? "" : null;
  215. } else {
  216. if (conn.useJulian) {
  217. args[parameterIndex - 1] = java.lang.Double.toString(SQLite.Database.julian_from_long(x.getTime()));
  218. } else {
  219. args[parameterIndex - 1] = x.toString();
  220. }
  221. }
  222. blobs[parameterIndex - 1] = false;
  223. }
  224. public void setTime(int parameterIndex, java.sql.Time x)
  225. throws SQLException {
  226. if (parameterIndex < 1 || parameterIndex > args.length) {
  227. throw new SQLException("bad parameter index");
  228. }
  229. if (x == null) {
  230. args[parameterIndex - 1] = nullrepl ? "" : null;
  231. } else {
  232. if (conn.useJulian) {
  233. args[parameterIndex - 1] = java.lang.Double.toString(SQLite.Database.julian_from_long(x.getTime()));
  234. } else {
  235. args[parameterIndex - 1] = x.toString();
  236. }
  237. }
  238. blobs[parameterIndex - 1] = false;
  239. }
  240. public void setTimestamp(int parameterIndex, java.sql.Timestamp x)
  241. throws SQLException {
  242. if (parameterIndex < 1 || parameterIndex > args.length) {
  243. throw new SQLException("bad parameter index");
  244. }
  245. if (x == null) {
  246. args[parameterIndex - 1] = nullrepl ? "" : null;
  247. } else {
  248. if (conn.useJulian) {
  249. args[parameterIndex - 1] = java.lang.Double.toString(SQLite.Database.julian_from_long(x.getTime()));
  250. } else {
  251. args[parameterIndex - 1] = x.toString();
  252. }
  253. }
  254. blobs[parameterIndex - 1] = false;
  255. }
  256. public void setAsciiStream(int parameterIndex, java.io.InputStream x,
  257. int length) throws SQLException {
  258. throw new SQLException("not supported");
  259. }
  260. @Deprecated
  261. public void setUnicodeStream(int parameterIndex, java.io.InputStream x,
  262. int length) throws SQLException {
  263. throw new SQLFeatureNotSupportedException();
  264. }
  265. public void setBinaryStream(int parameterIndex, java.io.InputStream x,
  266. int length) throws SQLException {
  267. try {
  268. byte[] data = new byte[length];
  269. x.read(data, 0, length);
  270. setBytes(parameterIndex, data);
  271. } catch (java.io.IOException e) {
  272. throw new SQLException("I/O failed");
  273. }
  274. }
  275. public void clearParameters() throws SQLException {
  276. for (int i = 0; i < args.length; i++) {
  277. args[i] = nullrepl ? "" : null;
  278. blobs[i] = false;
  279. }
  280. }
  281. public void setObject(int parameterIndex, Object x, int targetSqlType,
  282. int scale) throws SQLException {
  283. if (parameterIndex < 1 || parameterIndex > args.length) {
  284. throw new SQLException("bad parameter index");
  285. }
  286. if (x == null) {
  287. args[parameterIndex - 1] = nullrepl ? "" : null;
  288. } else {
  289. if (x instanceof byte[]) {
  290. byte[] bx = (byte[]) x;
  291. if (conn.db.is3()) {
  292. args[parameterIndex - 1] =
  293. SQLite.StringEncoder.encodeX(bx);
  294. blobs[parameterIndex - 1] = true;
  295. return;
  296. }
  297. args[parameterIndex - 1] = SQLite.StringEncoder.encode(bx);
  298. } else {
  299. args[parameterIndex - 1] = x.toString();
  300. }
  301. }
  302. blobs[parameterIndex - 1] = false;
  303. }
  304. public void setObject(int parameterIndex, Object x, int targetSqlType)
  305. throws SQLException {
  306. if (parameterIndex < 1 || parameterIndex > args.length) {
  307. throw new SQLException("bad parameter index");
  308. }
  309. if (x == null) {
  310. args[parameterIndex - 1] = nullrepl ? "" : null;
  311. } else {
  312. if (x instanceof byte[]) {
  313. byte[] bx = (byte[]) x;
  314. if (conn.db.is3()) {
  315. args[parameterIndex - 1] =
  316. SQLite.StringEncoder.encodeX(bx);
  317. blobs[parameterIndex - 1] = true;
  318. return;
  319. }
  320. args[parameterIndex - 1] = SQLite.StringEncoder.encode(bx);
  321. } else {
  322. args[parameterIndex - 1] = x.toString();
  323. }
  324. }
  325. blobs[parameterIndex - 1] = false;
  326. }
  327. public void setObject(int parameterIndex, Object x) throws SQLException {
  328. if (parameterIndex < 1 || parameterIndex > args.length) {
  329. throw new SQLException("bad parameter index");
  330. }
  331. if (x == null) {
  332. args[parameterIndex - 1] = nullrepl ? "" : null;
  333. } else {
  334. if (x instanceof byte[]) {
  335. byte[] bx = (byte[]) x;
  336. if (conn.db.is3()) {
  337. args[parameterIndex - 1] =
  338. SQLite.StringEncoder.encodeX(bx);
  339. blobs[parameterIndex - 1] = true;
  340. return;
  341. }
  342. args[parameterIndex - 1] = SQLite.StringEncoder.encode(bx);
  343. } else {
  344. args[parameterIndex - 1] = x.toString();
  345. }
  346. }
  347. blobs[parameterIndex - 1] = false;
  348. }
  349. public boolean execute() throws SQLException {
  350. return executeQuery(fixup2(sql), args, false) != null;
  351. }
  352. public void addBatch() throws SQLException {
  353. if (batch == null) {
  354. batch = new ArrayList<BatchArg>(args.length);
  355. }
  356. for (int i = 0; i < args.length; i++) {
  357. batch.add(new BatchArg(args[i], blobs[i]));
  358. }
  359. }
  360. public int[] executeBatch() throws SQLException {
  361. if (batch == null) {
  362. return new int[0];
  363. }
  364. int[] ret = new int[batch.size() / args.length];
  365. for (int i = 0; i < ret.length; i++) {
  366. ret[i] = EXECUTE_FAILED;
  367. }
  368. int errs = 0;
  369. int index = 0;
  370. for (int i = 0; i < ret.length; i++) {
  371. for (int k = 0; k < args.length; k++) {
  372. BatchArg b = (BatchArg) batch.get(index++);
  373. args[k] = b.arg;
  374. blobs[k] = b.blob;
  375. }
  376. try {
  377. ret[i] = executeUpdate();
  378. } catch (SQLException e) {
  379. ++errs;
  380. }
  381. }
  382. if (errs > 0) {
  383. throw new BatchUpdateException("batch failed", ret);
  384. }
  385. return ret;
  386. }
  387. public void clearBatch() throws SQLException {
  388. if (batch != null) {
  389. batch.clear();
  390. batch = null;
  391. }
  392. }
  393. public void close() throws SQLException {
  394. clearBatch();
  395. super.close();
  396. }
  397. public void setCharacterStream(int parameterIndex,
  398. java.io.Reader reader,
  399. int length) throws SQLException {
  400. try {
  401. char[] data = new char[length];
  402. reader.read(data);
  403. setString(parameterIndex, new String(data));
  404. } catch (java.io.IOException e) {
  405. throw new SQLException("I/O failed");
  406. }
  407. }
  408. public void setRef(int i, Ref x) throws SQLException {
  409. throw new SQLFeatureNotSupportedException();
  410. }
  411. public void setBlob(int i, Blob x) throws SQLException {
  412. throw new SQLFeatureNotSupportedException();
  413. }
  414. public void setClob(int i, Clob x) throws SQLException {
  415. throw new SQLFeatureNotSupportedException();
  416. }
  417. public void setArray(int i, Array x) throws SQLException {
  418. throw new SQLFeatureNotSupportedException();
  419. }
  420. public ResultSetMetaData getMetaData() throws SQLException {
  421. return rs.getMetaData();
  422. }
  423. public void setDate(int parameterIndex, java.sql.Date x, Calendar cal)
  424. throws SQLException {
  425. setDate(parameterIndex, x);
  426. }
  427. public void setTime(int parameterIndex, java.sql.Time x, Calendar cal)
  428. throws SQLException {
  429. setTime(parameterIndex, x);
  430. }
  431. public void setTimestamp(int parameterIndex, java.sql.Timestamp x,
  432. Calendar cal) throws SQLException {
  433. setTimestamp(parameterIndex, x);
  434. }
  435. public void setNull(int parameterIndex, int sqlType, String typeName)
  436. throws SQLException {
  437. setNull(parameterIndex, sqlType);
  438. }
  439. public ParameterMetaData getParameterMetaData() throws SQLException {
  440. throw new SQLException("not supported");
  441. }
  442. public void registerOutputParameter(String parameterName, int sqlType)
  443. throws SQLException {
  444. throw new SQLException("not supported");
  445. }
  446. public void registerOutputParameter(String parameterName, int sqlType,
  447. int scale)
  448. throws SQLException {
  449. throw new SQLException("not supported");
  450. }
  451. public void registerOutputParameter(String parameterName, int sqlType,
  452. String typeName)
  453. throws SQLException {
  454. throw new SQLException("not supported");
  455. }
  456. public java.net.URL getURL(int parameterIndex) throws SQLException {
  457. throw new SQLException("not supported");
  458. }
  459. public void setURL(int parameterIndex, java.net.URL url)
  460. throws SQLException {
  461. throw new SQLException("not supported");
  462. }
  463. public void setNull(String parameterName, int sqlType)
  464. throws SQLException {
  465. throw new SQLException("not supported");
  466. }
  467. public void setBoolean(String parameterName, boolean val)
  468. throws SQLException {
  469. throw new SQLException("not supported");
  470. }
  471. public void setByte(String parameterName, byte val)
  472. throws SQLException {
  473. throw new SQLException("not supported");
  474. }
  475. public void setShort(String parameterName, short val)
  476. throws SQLException {
  477. throw new SQLException("not supported");
  478. }
  479. public void setInt(String parameterName, int val)
  480. throws SQLException {
  481. throw new SQLException("not supported");
  482. }
  483. public void setLong(String parameterName, long val)
  484. throws SQLException {
  485. throw new SQLException("not supported");
  486. }
  487. public void setFloat(String parameterName, float val)
  488. throws SQLException {
  489. throw new SQLException("not supported");
  490. }
  491. public void setDouble(String parameterName, double val)
  492. throws SQLException {
  493. throw new SQLException("not supported");
  494. }
  495. public void setBigDecimal(String parameterName, BigDecimal val)
  496. throws SQLException {
  497. throw new SQLException("not supported");
  498. }
  499. public void setString(String parameterName, String val)
  500. throws SQLException {
  501. throw new SQLException("not supported");
  502. }
  503. public void setBytes(String parameterName, byte val[])
  504. throws SQLException {
  505. throw new SQLException("not supported");
  506. }
  507. public void setDate(String parameterName, java.sql.Date val)
  508. throws SQLException {
  509. throw new SQLException("not supported");
  510. }
  511. public void setTime(String parameterName, java.sql.Time val)
  512. throws SQLException {
  513. throw new SQLException("not supported");
  514. }
  515. public void setTimestamp(String parameterName, java.sql.Timestamp val)
  516. throws SQLException {
  517. throw new SQLException("not supported");
  518. }
  519. public void setAsciiStream(String parameterName,
  520. java.io.InputStream s, int length)
  521. throws SQLException {
  522. throw new SQLException("not supported");
  523. }
  524. public void setBinaryStream(String parameterName,
  525. java.io.InputStream s, int length)
  526. throws SQLException {
  527. throw new SQLException("not supported");
  528. }
  529. public void setObject(String parameterName, Object val, int targetSqlType,
  530. int scale)
  531. throws SQLException {
  532. throw new SQLException("not supported");
  533. }
  534. public void setObject(String parameterName, Object val, int targetSqlType)
  535. throws SQLException {
  536. throw new SQLException("not supported");
  537. }
  538. public void setObject(String parameterName, Object val)
  539. throws SQLException {
  540. throw new SQLException("not supported");
  541. }
  542. public void setCharacterStream(String parameterName,
  543. java.io.Reader r, int length)
  544. throws SQLException {
  545. throw new SQLException("not supported");
  546. }
  547. public void setDate(String parameterName, java.sql.Date val,
  548. Calendar cal)
  549. throws SQLException {
  550. throw new SQLException("not supported");
  551. }
  552. public void setTime(String parameterName, java.sql.Time val,
  553. Calendar cal)
  554. throws SQLException {
  555. throw new SQLException("not supported");
  556. }
  557. public void setTimestamp(String parameterName, java.sql.Timestamp val,
  558. Calendar cal)
  559. throws SQLException {
  560. throw new SQLException("not supported");
  561. }
  562. public void setNull(String parameterName, int sqlType, String typeName)
  563. throws SQLException {
  564. throw new SQLException("not supported");
  565. }
  566. public String getString(String parameterName) throws SQLException {
  567. throw new SQLException("not supported");
  568. }
  569. public boolean getBoolean(String parameterName) throws SQLException {
  570. throw new SQLException("not supported");
  571. }
  572. public byte getByte(String parameterName) throws SQLException {
  573. throw new SQLException("not supported");
  574. }
  575. public short getShort(String parameterName) throws SQLException {
  576. throw new SQLException("not supported");
  577. }
  578. public int getInt(String parameterName) throws SQLException {
  579. throw new SQLException("not supported");
  580. }
  581. public long getLong(String parameterName) throws SQLException {
  582. throw new SQLException("not supported");
  583. }
  584. public float getFloat(String parameterName) throws SQLException {
  585. throw new SQLException("not supported");
  586. }
  587. public double getDouble(String parameterName) throws SQLException {
  588. throw new SQLException("not supported");
  589. }
  590. public byte[] getBytes(String parameterName) throws SQLException {
  591. throw new SQLException("not supported");
  592. }
  593. public java.sql.Date getDate(String parameterName) throws SQLException {
  594. throw new SQLException("not supported");
  595. }
  596. public java.sql.Time getTime(String parameterName) throws SQLException {
  597. throw new SQLException("not supported");
  598. }
  599. public java.sql.Timestamp getTimestamp(String parameterName)
  600. throws SQLException {
  601. throw new SQLException("not supported");
  602. }
  603. public Object getObject(String parameterName) throws SQLException {
  604. throw new SQLException("not supported");
  605. }
  606. public Object getObject(int parameterIndex) throws SQLException {
  607. throw new SQLException("not supported");
  608. }
  609. public BigDecimal getBigDecimal(String parameterName) throws SQLException {
  610. throw new SQLException("not supported");
  611. }
  612. public Object getObject(String parameterName, Map map)
  613. throws SQLException {
  614. throw new SQLException("not supported");
  615. }
  616. public Object getObject(int parameterIndex, Map map)
  617. throws SQLException {
  618. throw new SQLException("not supported");
  619. }
  620. public Ref getRef(int parameterIndex) throws SQLException {
  621. throw new SQLException("not supported");
  622. }
  623. public Ref getRef(String parameterName) throws SQLException {
  624. throw new SQLException("not supported");
  625. }
  626. public Blob getBlob(String parameterName) throws SQLException {
  627. throw new SQLException("not supported");
  628. }
  629. public Blob getBlob(int parameterIndex) throws SQLException {
  630. throw new SQLException("not supported");
  631. }
  632. public Clob getClob(String parameterName) throws SQLException {
  633. throw new SQLException("not supported");
  634. }
  635. public Clob getClob(int parameterIndex) throws SQLException {
  636. throw new SQLException("not supported");
  637. }
  638. public Array getArray(String parameterName) throws SQLException {
  639. throw new SQLException("not supported");
  640. }
  641. public Array getArray(int parameterIndex) throws SQLException {
  642. throw new SQLException("not supported");
  643. }
  644. public java.sql.Date getDate(String parameterName, Calendar cal)
  645. throws SQLException {
  646. throw new SQLException("not supported");
  647. }
  648. public java.sql.Date getDate(int parameterIndex, Calendar cal)
  649. throws SQLException {
  650. throw new SQLException("not supported");
  651. }
  652. public java.sql.Time getTime(String parameterName, Calendar cal)
  653. throws SQLException {
  654. throw new SQLException("not supported");
  655. }
  656. public java.sql.Time getTime(int parameterIndex, Calendar cal)
  657. throws SQLException {
  658. throw new SQLException("not supported");
  659. }
  660. public java.sql.Timestamp getTimestamp(String parameterName, Calendar cal)
  661. throws SQLException {
  662. throw new SQLException("not supported");
  663. }
  664. public java.sql.Timestamp getTimestamp(int parameterIndex, Calendar cal)
  665. throws SQLException {
  666. throw new SQLException("not supported");
  667. }
  668. public java.net.URL getURL(String parameterName) throws SQLException {
  669. throw new SQLException("not supported");
  670. }
  671. public void setRowId(int parameterIndex, RowId x) throws SQLException {
  672. throw new SQLFeatureNotSupportedException();
  673. }
  674. public void setRowId(String parameterName, RowId x) throws SQLException {
  675. throw new SQLFeatureNotSupportedException();
  676. }
  677. public void setNString(int parameterIndex, String value)
  678. throws SQLException {
  679. throw new SQLFeatureNotSupportedException();
  680. }
  681. public void setNString(String parameterName, String value)
  682. throws SQLException {
  683. throw new SQLFeatureNotSupportedException();
  684. }
  685. public void setNCharacterStream(int parameterIndex, java.io.Reader x,
  686. long len)
  687. throws SQLException {
  688. throw new SQLFeatureNotSupportedException();
  689. }
  690. public void setNCharacterStream(String parameterName, java.io.Reader x,
  691. long len)
  692. throws SQLException {
  693. throw new SQLFeatureNotSupportedException();
  694. }
  695. public void setNClob(int parameterIndex, NClob value)
  696. throws SQLException {
  697. throw new SQLFeatureNotSupportedException();
  698. }
  699. public void setNClob(String parameterName, NClob value)
  700. throws SQLException {
  701. throw new SQLFeatureNotSupportedException();
  702. }
  703. public void setClob(int parameterIndex, java.io.Reader x, long len)
  704. throws SQLException {
  705. throw new SQLFeatureNotSupportedException();
  706. }
  707. public void setClob(String parameterName, java.io.Reader x, long len)
  708. throws SQLException {
  709. throw new SQLFeatureNotSupportedException();
  710. }
  711. public void setBlob(int parameterIndex, java.io.InputStream x, long len)
  712. throws SQLException {
  713. throw new SQLFeatureNotSupportedException();
  714. }
  715. public void setBlob(String parameterName, java.io.InputStream x, long len)
  716. throws SQLException {
  717. throw new SQLFeatureNotSupportedException();
  718. }
  719. public void setNClob(int parameterIndex, java.io.Reader x, long len)
  720. throws SQLException {
  721. throw new SQLFeatureNotSupportedException();
  722. }
  723. public void setNClob(String parameterName, java.io.Reader x, long len)
  724. throws SQLException {
  725. throw new SQLFeatureNotSupportedException();
  726. }
  727. public void setSQLXML(int parameterIndex, SQLXML xml)
  728. throws SQLException {
  729. throw new SQLFeatureNotSupportedException();
  730. }
  731. public void setSQLXML(String parameterName, SQLXML xml)
  732. throws SQLException {
  733. throw new SQLFeatureNotSupportedException();
  734. }
  735. public void setAsciiStream(int parameterIndex, java.io.InputStream x,
  736. long len)
  737. throws SQLException {
  738. throw new SQLFeatureNotSupportedException();
  739. }
  740. public void setAsciiStream(String parameterName, java.io.InputStream x,
  741. long len)
  742. throws SQLException {
  743. throw new SQLFeatureNotSupportedException();
  744. }
  745. public void setBinaryStream(int parameterIndex, java.io.InputStream x,
  746. long len)
  747. throws SQLException {
  748. throw new SQLFeatureNotSupportedException();
  749. }
  750. public void setBinaryStream(String parameterName, java.io.InputStream x,
  751. long len)
  752. throws SQLException {
  753. throw new SQLFeatureNotSupportedException();
  754. }
  755. public void setCharacterStream(int parameterIndex, java.io.Reader x,
  756. long len)
  757. throws SQLException {
  758. throw new SQLFeatureNotSupportedException();
  759. }
  760. public void setCharacterStream(String parameterName, java.io.Reader x,
  761. long len)
  762. throws SQLException {
  763. throw new SQLFeatureNotSupportedException();
  764. }
  765. public void setAsciiStream(int parameterIndex, java.io.InputStream x)
  766. throws SQLException {
  767. throw new SQLFeatureNotSupportedException();
  768. }
  769. public void setAsciiStream(String parameterName, java.io.InputStream x)
  770. throws SQLException {
  771. throw new SQLFeatureNotSupportedException();
  772. }
  773. public void setBinaryStream(int parameterIndex, java.io.InputStream x)
  774. throws SQLException {
  775. throw new SQLFeatureNotSupportedException();
  776. }
  777. public void setBinaryStream(String parameterName, java.io.InputStream x)
  778. throws SQLException {
  779. throw new SQLFeatureNotSupportedException();
  780. }
  781. public void setCharacterStream(int parameterIndex, java.io.Reader x)
  782. throws SQLException {
  783. throw new SQLFeatureNotSupportedException();
  784. }
  785. public void setCharacterStream(String parameterName, java.io.Reader x)
  786. throws SQLException {
  787. throw new SQLFeatureNotSupportedException();
  788. }
  789. public void setNCharacterStream(int parameterIndex, java.io.Reader x)
  790. throws SQLException {
  791. throw new SQLFeatureNotSupportedException();
  792. }
  793. public void setNCharacterStream(String parameterName, java.io.Reader x)
  794. throws SQLException {
  795. throw new SQLFeatureNotSupportedException();
  796. }
  797. public void setClob(int parameterIndex, java.io.Reader x)
  798. throws SQLException {
  799. throw new SQLFeatureNotSupportedException();
  800. }
  801. public void setClob(String parameterName, java.io.Reader x)
  802. throws SQLException {
  803. throw new SQLFeatureNotSupportedException();
  804. }
  805. public void setBlob(int parameterIndex, java.io.InputStream x)
  806. throws SQLException {
  807. throw new SQLFeatureNotSupportedException();
  808. }
  809. public void setBlob(String parameterName, java.io.InputStream x)
  810. throws SQLException {
  811. throw new SQLFeatureNotSupportedException();
  812. }
  813. public void setNClob(int parameterIndex, java.io.Reader x)
  814. throws SQLException {
  815. throw new SQLFeatureNotSupportedException();
  816. }
  817. public void setNClob(String parameterName, java.io.Reader x)
  818. throws SQLException {
  819. throw new SQLFeatureNotSupportedException();
  820. }
  821. }