tajo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jihoon...@apache.org
Subject [2/3] TAJO-176: Implement Tajo JDBC Driver. (Keuntae Park via jihoon)
Date Mon, 18 Nov 2013 08:56:47 GMT
http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/342fd47f/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDatabaseMetaData.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDatabaseMetaData.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDatabaseMetaData.java
new file mode 100644
index 0000000..6c64ac2
--- /dev/null
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDatabaseMetaData.java
@@ -0,0 +1,1196 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.tajo.jdbc;
+
+import org.apache.tajo.TajoConstants;
+import org.apache.tajo.catalog.Column;
+import org.apache.tajo.catalog.TableDesc;
+import org.apache.tajo.client.TajoClient;
+import org.apache.tajo.common.TajoDataTypes.Type;
+import org.apache.tajo.datum.NullDatum;
+import org.apache.tajo.datum.TextDatum;
+
+import java.sql.*;
+import java.util.*;
+
+/**
+ * TajoDatabaseMetaData.
+ */
+public class TajoDatabaseMetaData implements DatabaseMetaData {
+  private static final char SEARCH_STRING_ESCAPE = '\\';
+
+  private final TajoConnection conn;
+
+  public TajoDatabaseMetaData(TajoConnection conn) {
+    this.conn = conn;
+  }
+
+  @Override
+  public boolean allProceduresAreCallable()
+      throws SQLException {
+    return true;
+  }
+
+  @Override
+  public boolean allTablesAreSelectable()
+      throws SQLException {
+    return true;
+  }
+
+  @Override
+  public String getURL()
+      throws SQLException {
+    return conn.getUri();
+  }
+
+  @Override
+  public String getUserName()
+      throws SQLException {
+    return "tajo";
+  }
+
+  @Override
+  public boolean isReadOnly()
+      throws SQLException {
+    return true;
+  }
+
+  @Override
+  public String getDatabaseProductName()
+      throws SQLException {
+    return "Tajo";
+  }
+
+  @Override
+  public String getDatabaseProductVersion()
+      throws SQLException {
+    //TODO get from tajo master
+    return TajoConstants.TAJO_VERSION;
+  }
+
+  @Override
+  public String getDriverName()
+      throws SQLException {
+    return "tajo";
+  }
+
+  @Override
+  public String getDriverVersion()
+      throws SQLException {
+    return TajoDriver.MAJOR_VERSION + "." + TajoDriver.MINOR_VERSION;
+  }
+
+  @Override
+  public int getDriverMajorVersion() {
+    return TajoDriver.MAJOR_VERSION;
+  }
+
+  @Override
+  public int getDriverMinorVersion() {
+    return TajoDriver.MINOR_VERSION;
+  }
+
+  @Override
+  public String getIdentifierQuoteString()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getIdentifierQuoteString not supported");
+  }
+
+  @Override
+  public String getSQLKeywords()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getSQLKeywords not supported");
+  }
+
+  @Override
+  public String getNumericFunctions()
+      throws SQLException {
+    return "";
+  }
+
+  @Override
+  public String getStringFunctions()
+      throws SQLException {
+    return "";
+  }
+
+  @Override
+  public String getSystemFunctions()
+      throws SQLException {
+    return "";
+  }
+
+  @Override
+  public String getTimeDateFunctions()
+      throws SQLException {
+    return "";
+  }
+
+  @Override
+  public String getSearchStringEscape()
+      throws SQLException {
+    return "\\";
+  }
+
+  @Override
+  public String getExtraNameCharacters()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getExtraNameCharacters not supported");
+  }
+
+  @Override
+  public String getSchemaTerm()
+      throws SQLException {
+    return "";
+  }
+
+  @Override
+  public String getProcedureTerm()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getProcedureTerm not supported");
+  }
+
+  @Override
+  public String getCatalogTerm()
+      throws SQLException {
+    return "database";
+  }
+
+  @Override
+  public String getCatalogSeparator()
+      throws SQLException {
+    return ".";
+  }
+
+  @Override
+  public int getMaxBinaryLiteralLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxBinaryLiteralLength not supported");
+  }
+
+  @Override
+  public int getMaxCharLiteralLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxCharLiteralLength not supported");
+  }
+
+  @Override
+  public int getMaxColumnNameLength()
+      throws SQLException {
+    return 128;
+  }
+
+  @Override
+  public int getMaxColumnsInGroupBy()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxColumnsInGroupBy not supported");
+  }
+
+  @Override
+  public int getMaxColumnsInIndex()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxColumnsInIndex not supported");
+  }
+
+  @Override
+  public int getMaxColumnsInOrderBy()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxColumnsInOrderBy not supported");
+  }
+
+  @Override
+  public int getMaxColumnsInSelect()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxColumnsInSelect not supported");
+  }
+
+  @Override
+  public int getMaxColumnsInTable()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxColumnsInTable not supported");
+  }
+
+  @Override
+  public int getMaxConnections()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxConnections not supported");
+  }
+
+  @Override
+  public int getMaxCursorNameLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxCursorNameLength not supported");
+  }
+
+  @Override
+  public int getMaxIndexLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxIndexLength not supported");
+  }
+
+  @Override
+  public int getMaxSchemaNameLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxSchemaNameLength not supported");
+  }
+
+  @Override
+  public int getMaxProcedureNameLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxProcedureNameLength not supported");
+  }
+
+  @Override
+  public int getMaxCatalogNameLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxCatalogNameLength not supported");
+  }
+
+  @Override
+  public int getMaxRowSize()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxRowSize not supported");
+  }
+
+  @Override
+  public boolean doesMaxRowSizeIncludeBlobs()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("doesMaxRowSizeIncludeBlobs not supported");
+  }
+
+  @Override
+  public int getMaxStatementLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxStatementLength not supported");
+  }
+
+  @Override
+  public int getMaxStatements()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxStatements not supported");
+  }
+
+  @Override
+  public int getMaxTableNameLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxTableNameLength not supported");
+  }
+
+  @Override
+  public int getMaxTablesInSelect()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxTablesInSelect not supported");
+  }
+
+  @Override
+  public int getMaxUserNameLength()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxUserNameLength not supported");
+  }
+
+  @Override
+  public int getDefaultTransactionIsolation()
+      throws SQLException {
+    return Connection.TRANSACTION_NONE;
+  }
+
+  @Override
+  public boolean dataDefinitionCausesTransactionCommit()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("dataDefinitionCausesTransactionCommit not supported");
+  }
+
+  @Override
+  public boolean dataDefinitionIgnoredInTransactions()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("dataDefinitionIgnoredInTransactions not supported");
+  }
+
+  @Override
+  public ResultSet getProcedures(String catalog, String schemaPattern, String procedureNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("stored procedures not supported");
+  }
+
+  @Override
+  public ResultSet getProcedureColumns(String catalog, String schemaPattern, String procedureNamePattern, String columnNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("stored procedures not supported");
+  }
+
+  /**
+   * Convert a pattern containing JDBC catalog search wildcards into
+   * Java regex patterns.
+   *
+   * @param pattern input which may contain '%' or '_' wildcard characters, or
+   * these characters escaped using {@link #getSearchStringEscape()}.
+   * @return replace %/_ with regex search characters, also handle escaped
+   * characters.
+   */
+  private String convertPattern(final String pattern) {
+    if (pattern == null) {
+      return ".*";
+    } else {
+      StringBuilder result = new StringBuilder(pattern.length());
+
+      boolean escaped = false;
+      for (int i = 0, len = pattern.length(); i < len; i++) {
+        char c = pattern.charAt(i);
+        if (escaped) {
+          if (c != SEARCH_STRING_ESCAPE) {
+            escaped = false;
+          }
+          result.append(c);
+        } else {
+          if (c == SEARCH_STRING_ESCAPE) {
+            escaped = true;
+            continue;
+          } else if (c == '%') {
+            result.append(".*");
+          } else if (c == '_') {
+            result.append('.');
+          } else {
+            result.append(Character.toLowerCase(c));
+          }
+        }
+      }
+
+      return result.toString();
+    }
+  }
+
+  @Override
+  public ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)
+      throws SQLException {
+    try {
+      final List<MetaDataTuple> resultTables = new ArrayList<MetaDataTuple>();
+      final String resultCatalog;
+      if (catalog == null) {
+        resultCatalog = "default";
+      } else {
+        resultCatalog = catalog;
+      }
+
+      String regtableNamePattern = convertPattern(tableNamePattern);
+      try {
+        TajoClient tajoClient = conn.getTajoClient();
+        List<String> tableNames = tajoClient.getTableList();
+        for (String eachTableName: tableNames) {
+          if (eachTableName.matches(regtableNamePattern)) {
+            MetaDataTuple tuple = new MetaDataTuple(5);
+
+            int index = 0;
+            tuple.put(index++, new TextDatum(resultCatalog));  //TABLE_CAT
+            tuple.put(index++, NullDatum.get());   //TABLE_SCHEM
+            tuple.put(index++, new TextDatum(eachTableName));
+            tuple.put(index++, new TextDatum("TABLE"));   //TABLE_TYPE
+            tuple.put(index++, NullDatum.get());   //REMARKS
+
+            resultTables.add(tuple);
+          }
+        }
+        Collections.sort(resultTables, new Comparator<MetaDataTuple> () {
+          @Override
+          public int compare(MetaDataTuple table1, MetaDataTuple table2) {
+            return table1.getString(2).compareTo(table2.getString(2));
+          }
+        });
+      } catch (Exception e) {
+        e.printStackTrace();
+        throw new SQLException(e);
+      }
+      TajoMetaDataResultSet result = new TajoMetaDataResultSet(
+          Arrays.asList("TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", "TABLE_TYPE", "REMARKS"),
+          Arrays.asList(Type.VARCHAR, Type.VARCHAR, Type.VARCHAR, Type.VARCHAR, Type.VARCHAR),
+          resultTables);
+
+      return result;
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw new SQLException(e.getMessage(), e);
+    }
+  }
+
+  @Override
+  public ResultSet getSchemas()
+      throws SQLException {
+    return getSchemas(null, null);
+  }
+
+  @Override
+  public ResultSet getCatalogs()
+      throws SQLException {
+    List<MetaDataTuple> columns = new ArrayList<MetaDataTuple>();
+    MetaDataTuple tuple = new MetaDataTuple(1);
+    tuple.put(0, new TextDatum("default"));
+    columns.add(tuple);
+
+    ResultSet result = new TajoMetaDataResultSet(
+        Arrays.asList("TABLE_CAT")
+        , Arrays.asList(Type.VARCHAR)
+        , columns);
+
+    return result;
+  }
+
+  @Override
+  public ResultSet getTableTypes()
+      throws SQLException {
+    List<MetaDataTuple> columns = new ArrayList<MetaDataTuple>();
+    MetaDataTuple tuple = new MetaDataTuple(1);
+    tuple.put(0, new TextDatum("TABLE"));
+    columns.add(tuple);
+
+    ResultSet result = new TajoMetaDataResultSet(
+        Arrays.asList("TABLE_TYPE")
+        , Arrays.asList(Type.VARCHAR)
+        , columns);
+
+    return result;
+  }
+
+  @Override
+  public ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types)
+      throws SQLException {
+    List<MetaDataTuple> columns = new ArrayList<MetaDataTuple>();
+
+    return new TajoMetaDataResultSet(
+        Arrays.asList("TYPE_CAT", "TYPE_SCHEM", "TYPE_NAME", "CLASS_NAME", "DATA_TYPE"
+            , "REMARKS", "BASE_TYPE")
+        , Arrays.asList(Type.VARCHAR, Type.VARCHAR, Type.VARCHAR, Type.VARCHAR, Type.INT4, Type.VARCHAR, Type.INT4)
+        , columns);
+  }
+
+  @Override
+  public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)
+      throws SQLException {
+    List<MetaDataTuple> columns = new ArrayList<MetaDataTuple>();
+    try {
+      if (catalog == null) {
+        catalog = "default";
+      }
+
+      String regtableNamePattern = convertPattern(tableNamePattern);
+      String regcolumnNamePattern = convertPattern(columnNamePattern);
+
+      List<String> tables = conn.getTajoClient().getTableList();
+      for (String table: tables) {
+        if (table.matches(regtableNamePattern)) {
+          TableDesc tableDesc = conn.getTajoClient().getTableDesc(table);
+          int pos = 0;
+          for (Column column: tableDesc.getSchema().getColumns()) {
+            if (column.getColumnName().matches(regcolumnNamePattern)) {
+              MetaDataTuple tuple = new MetaDataTuple(22);
+
+              int index = 0;
+              tuple.put(index++, new TextDatum(catalog));  //TABLE_CAT
+              tuple.put(index++, NullDatum.get());  //TABLE_SCHEM
+              tuple.put(index++, new TextDatum(table));  //TABLE_NAME
+              tuple.put(index++, new TextDatum(column.getColumnName()));  //COLUMN_NAME
+              tuple.put(index++, new TextDatum("" + TajoDriver.tajoTypeToSqlType(column.getDataType())));  //TODO DATA_TYPE
+              tuple.put(index++, new TextDatum(TajoDriver.toSqlType(column.getDataType())));  //TYPE_NAME
+              tuple.put(index++, new TextDatum("0"));  //COLUMN_SIZE
+              tuple.put(index++, new TextDatum("0"));  //BUFFER_LENGTH
+              tuple.put(index++, new TextDatum("0"));  //DECIMAL_DIGITS
+              tuple.put(index++, new TextDatum("0"));  //NUM_PREC_RADIX
+              tuple.put(index++, new TextDatum("" + DatabaseMetaData.columnNullable));  //NULLABLE
+              tuple.put(index++, NullDatum.get());  //REMARKS
+              tuple.put(index++, NullDatum.get());  //COLUMN_DEF
+              tuple.put(index++, NullDatum.get());  //SQL_DATA_TYPE
+              tuple.put(index++, NullDatum.get());  //SQL_DATETIME_SUB
+              tuple.put(index++, new TextDatum("0"));  //CHAR_OCTET_LENGTH
+              tuple.put(index++, new TextDatum("" + pos));  //ORDINAL_POSITION
+              tuple.put(index++, new TextDatum("YES"));  //IS_NULLABLE
+              tuple.put(index++, NullDatum.get());  //SCOPE_CATLOG
+              tuple.put(index++, NullDatum.get());  //SCOPE_SCHEMA
+              tuple.put(index++, NullDatum.get());  //SCOPE_TABLE
+              tuple.put(index++, new TextDatum("0"));  //SOURCE_DATA_TYPE
+              columns.add(tuple);
+            }
+            pos++;
+          }
+        }
+      }
+
+      return new TajoMetaDataResultSet(
+          Arrays.asList("TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", "COLUMN_NAME", "DATA_TYPE"
+              , "TYPE_NAME", "COLUMN_SIZE", "BUFFER_LENGTH", "DECIMAL_DIGITS", "NUM_PREC_RADIX"
+              , "NULLABLE", "REMARKS", "COLUMN_DEF", "SQL_DATA_TYPE", "SQL_DATETIME_SUB"
+              , "CHAR_OCTET_LENGTH", "ORDINAL_POSITION", "IS_NULLABLE", "SCOPE_CATLOG", "SCOPE_SCHEMA"
+              , "SCOPE_TABLE", "SOURCE_DATA_TYPE")
+          , Arrays.asList(Type.VARCHAR, Type.VARCHAR, Type.VARCHAR, Type.VARCHAR, Type.INT4
+              , Type.VARCHAR, Type.INT4, Type.INT4, Type.INT4, Type.INT4
+              , Type.INT4, Type.VARCHAR, Type.VARCHAR, Type.INT4, Type.INT4
+              , Type.INT4, Type.INT4, Type.VARCHAR, Type.VARCHAR, Type.VARCHAR
+              , Type.VARCHAR, Type.INT4)
+          , columns);
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw new SQLException(e);
+    }
+  }
+
+  @Override
+  public ResultSet getColumnPrivileges(String catalog, String schema, String table, String columnNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("privileges not supported");
+  }
+
+  @Override
+  public ResultSet getTablePrivileges(String catalog, String schemaPattern, String tableNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("privileges not supported");
+  }
+
+  @Override
+  public ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("row identifiers not supported");
+  }
+
+  @Override
+  public ResultSet getVersionColumns(String catalog, String schema, String table)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("version columns not supported");
+  }
+
+  @Override
+  public ResultSet getPrimaryKeys(String catalog, String schema, String table)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("primary keys not supported");
+  }
+
+  @Override
+  public ResultSet getImportedKeys(String catalog, String schema, String table)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("imported keys not supported");
+  }
+
+  @Override
+  public ResultSet getExportedKeys(String catalog, String schema, String table)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("exported keys not supported");
+  }
+
+  @Override
+  public ResultSet getCrossReference(String parentCatalog, String parentSchema, String parentTable, String foreignCatalog, String foreignSchema, String foreignTable)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("cross reference not supported");
+  }
+
+  @Override
+  public ResultSet getTypeInfo()
+      throws SQLException {
+    throw new UnsupportedOperationException("getTypeInfo not supported");
+  }
+
+  @Override
+  public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("indexes not supported");
+  }
+
+  @Override
+  public boolean deletesAreDetected(int type)
+      throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean insertsAreDetected(int type)
+      throws SQLException {
+    return false;
+  }
+
+  @Override
+  public Connection getConnection()
+      throws SQLException {
+    return conn;
+  }
+
+  @Override
+  public ResultSet getSuperTypes(String catalog, String schemaPattern, String typeNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("type hierarchies not supported");
+  }
+
+  @Override
+  public ResultSet getSuperTables(String catalog, String schemaPattern, String tableNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("type hierarchies not supported");
+  }
+
+  @Override
+  public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("user-defined types not supported");
+  }
+
+  @Override
+  public int getResultSetHoldability()
+      throws SQLException {
+    return ResultSet.HOLD_CURSORS_OVER_COMMIT;
+  }
+
+  @Override
+  public int getDatabaseMajorVersion()
+      throws SQLException {
+    return TajoDriver.MAJOR_VERSION;
+  }
+
+  @Override
+  public int getDatabaseMinorVersion()
+      throws SQLException {
+    return TajoDriver.MINOR_VERSION;
+  }
+
+  @Override
+  public int getJDBCMajorVersion()
+      throws SQLException {
+    return TajoDriver.JDBC_VERSION_MAJOR;
+  }
+
+  @Override
+  public int getJDBCMinorVersion()
+      throws SQLException {
+    return TajoDriver.JDBC_VERSION_MINOR;
+  }
+
+  @Override
+  public int getSQLStateType()
+      throws SQLException {
+    return DatabaseMetaData.sqlStateSQL;
+  }
+
+  @Override
+  public RowIdLifetime getRowIdLifetime()
+      throws SQLException {
+    return RowIdLifetime.ROWID_UNSUPPORTED;
+  }
+
+  @Override
+  public ResultSet getSchemas(String catalog, String schemaPattern)
+      throws SQLException {
+    return new TajoMetaDataResultSet(
+        Arrays.asList("TABLE_SCHEM", "TABLE_CATALOG"),
+        Arrays.asList(Type.VARCHAR, Type.VARCHAR),
+        null);
+  }
+
+  @Override
+  public boolean autoCommitFailureClosesAllResultSets()
+      throws SQLException {
+    return false;
+  }
+
+  @Override
+  public ResultSet getClientInfoProperties()
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getClientInfoProperties not supported");
+  }
+
+  @Override
+  public ResultSet getFunctions(String catalog, String schemaPattern, String functionNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getFunctions not supported");
+  }
+
+  @Override
+  public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("getFunctionColumns not supported");
+  }
+
+  @Override
+  public boolean isCatalogAtStart() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean locatorsUpdateCopy() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean nullPlusNonNullIsNull() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean nullsAreSortedAtEnd() throws SQLException {
+    return true;
+  }
+
+  @Override
+  public boolean nullsAreSortedAtStart() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean nullsAreSortedHigh() throws SQLException {
+    return true;
+  }
+
+  @Override
+  public boolean nullsAreSortedLow() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean othersDeletesAreVisible(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean othersInsertsAreVisible(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean othersUpdatesAreVisible(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean ownDeletesAreVisible(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean ownInsertsAreVisible(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean ownUpdatesAreVisible(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean storesLowerCaseIdentifiers() throws SQLException {
+    return true;
+  }
+
+  @Override
+  public boolean storesLowerCaseQuotedIdentifiers() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean storesMixedCaseIdentifiers() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean storesMixedCaseQuotedIdentifiers() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean storesUpperCaseIdentifiers() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean storesUpperCaseQuotedIdentifiers() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsANSI92EntryLevelSQL() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsANSI92FullSQL() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsANSI92IntermediateSQL() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsAlterTableWithAddColumn() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsAlterTableWithDropColumn() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsBatchUpdates() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsCatalogsInDataManipulation() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsCatalogsInIndexDefinitions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsCatalogsInPrivilegeDefinitions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsCatalogsInProcedureCalls() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsCatalogsInTableDefinitions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsColumnAliasing() throws SQLException {
+    return true;
+  }
+
+  @Override
+  public boolean supportsConvert() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsConvert(int fromType, int toType) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsCoreSQLGrammar() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsCorrelatedSubqueries() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsDataDefinitionAndDataManipulationTransactions()
+      throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsDataManipulationTransactionsOnly() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsDifferentTableCorrelationNames() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsExpressionsInOrderBy() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsExtendedSQLGrammar() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsFullOuterJoins() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsGetGeneratedKeys() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsGroupBy() throws SQLException {
+    return true;
+  }
+
+  @Override
+  public boolean supportsGroupByBeyondSelect() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsGroupByUnrelated() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsIntegrityEnhancementFacility() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsLikeEscapeClause() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsLimitedOuterJoins() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsMinimumSQLGrammar() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsMixedCaseIdentifiers() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsMixedCaseQuotedIdentifiers() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsMultipleOpenResults() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsMultipleResultSets() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsMultipleTransactions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsNamedParameters() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsNonNullableColumns() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsOpenCursorsAcrossCommit() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsOpenCursorsAcrossRollback() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsOpenStatementsAcrossCommit() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsOpenStatementsAcrossRollback() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsOrderByUnrelated() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsOuterJoins() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsPositionedDelete() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsPositionedUpdate() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsResultSetConcurrency(int type, int concurrency)
+      throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsResultSetHoldability(int holdability)
+      throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsResultSetType(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSavepoints() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSchemasInDataManipulation() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSchemasInIndexDefinitions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSchemasInPrivilegeDefinitions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSchemasInProcedureCalls() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSchemasInTableDefinitions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSelectForUpdate() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsStatementPooling() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsStoredFunctionsUsingCallSyntax() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsStoredProcedures() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSubqueriesInComparisons() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSubqueriesInExists() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSubqueriesInIns() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsSubqueriesInQuantifieds() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsTableCorrelationNames() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsTransactionIsolationLevel(int level)
+      throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsTransactions() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsUnion() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean supportsUnionAll() throws SQLException {
+    return true;
+  }
+
+  @Override
+  public boolean updatesAreDetected(int type) throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean usesLocalFilePerTable() throws SQLException {
+    return false;
+  }
+
+  @Override
+  public boolean usesLocalFiles() throws SQLException {
+    return false;
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public <T> T unwrap(Class<T> iface)
+      throws SQLException {
+    if (isWrapperFor(iface)) {
+      return (T) this;
+    }
+    throw new SQLFeatureNotSupportedException("No wrapper for " + iface);
+  }
+
+  @Override
+  public boolean isWrapperFor(Class<?> iface)
+      throws SQLException {
+    return iface.isInstance(this);
+  }
+
+  public boolean generatedKeyAlwaysReturned() throws SQLException {
+    // JDK 1.7
+    throw new SQLFeatureNotSupportedException("generatedKeyAlwaysReturned not supported");
+  }
+
+  public ResultSet getPseudoColumns(String catalog, String schemaPattern,
+                                    String tableNamePattern, String columnNamePattern) throws SQLException {
+    // JDK 1.7
+    throw new SQLFeatureNotSupportedException("getPseudoColumns not supported");
+  }
+}
+

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/342fd47f/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDriver.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDriver.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDriver.java
new file mode 100644
index 0000000..ca0502f
--- /dev/null
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoDriver.java
@@ -0,0 +1,233 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.tajo.jdbc;
+
+import org.apache.tajo.common.TajoDataTypes;
+import org.apache.tajo.conf.TajoConf;
+import org.apache.tajo.exception.UnsupportedException;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.sql.*;
+import java.util.Properties;
+import java.util.logging.Logger;
+
+public class TajoDriver implements Driver, Closeable {
+  public static final int MAJOR_VERSION = 1;
+  public static final int MINOR_VERSION = 0;
+
+  public static final int JDBC_VERSION_MAJOR = 4;
+  public static final int JDBC_VERSION_MINOR = 0;
+
+  public static final String TAJO_JDBC_URL_PREFIX = "jdbc:tajo://";
+
+  protected static TajoConf jdbcTajoConf;
+
+  static {
+    try {
+      java.sql.DriverManager.registerDriver(new TajoDriver());
+    } catch (SQLException e) {
+      // TODO Auto-generated catch block
+      e.printStackTrace();
+    }
+  }
+
+  public TajoDriver() {
+    jdbcTajoConf = new TajoConf();
+  }
+
+  @Override
+  public void close() throws IOException {
+  }
+
+  @Override
+  public Connection connect(String url, Properties properties) throws SQLException {
+    return new TajoConnection(url, properties);
+  }
+
+  @Override
+  public boolean acceptsURL(String url) throws SQLException {
+    return url.startsWith(TAJO_JDBC_URL_PREFIX);
+  }
+
+  @Override
+  public DriverPropertyInfo[] getPropertyInfo(String s, Properties properties) throws SQLException {
+    return new DriverPropertyInfo[0];
+  }
+
+  @Override
+  public int getMajorVersion() {
+    return MAJOR_VERSION;
+  }
+
+  @Override
+  public int getMinorVersion() {
+    return MINOR_VERSION;
+  }
+
+  @Override
+  public boolean jdbcCompliant() {
+    return false;
+  }
+
+  public static String toSqlType(TajoDataTypes.DataType type) {
+    switch (type.getType()) {
+      case BOOLEAN:
+        return "boolean";
+      case INT1:
+        return "tinyint";
+      case INT2:
+        return "smallint";
+      case INT4:
+        return "integer";
+      case INT8:
+        return "bigint";
+      case FLOAT4:
+        return "float";
+      case FLOAT8:
+        return "float8";
+      case DECIMAL:
+        return "numeric";
+      case VARBINARY:
+        return "bytea";
+      case CHAR:
+        return "character";
+      case DATE:
+        return "date";
+      case VARCHAR:
+        return "varchar";
+      case TEXT:
+        return "varchar";
+      default:
+        throw new UnsupportedException("Unrecognized column type:" + type);
+    }
+  }
+
+  public static int tajoTypeToSqlType(TajoDataTypes.DataType type) throws SQLException {
+    switch (type.getType()) {
+      case BOOLEAN:
+        return Types.BOOLEAN;
+      case INT1:
+        return Types.TINYINT;
+      case INT2:
+        return Types.SMALLINT;
+      case INT4:
+        return Types.INTEGER;
+      case INT8:
+        return Types.BIGINT;
+      case FLOAT4:
+        return Types.FLOAT;
+      case FLOAT8:
+        return Types.DOUBLE;
+      case DECIMAL:
+        return Types.DECIMAL;
+      case DATE:
+        return Types.TIMESTAMP;
+      case VARCHAR:
+        return Types.VARCHAR;
+      case TEXT:
+        return Types.VARCHAR;
+      default:
+        throw new SQLException("Unrecognized column type: " + type);
+    }
+  }
+
+  static int columnDisplaySize(int columnType) throws SQLException {
+    // according to hiveTypeToSqlType possible options are:
+    switch(columnType) {
+      case Types.BOOLEAN:
+        return columnPrecision(columnType);
+      case Types.VARCHAR:
+        return Integer.MAX_VALUE; // hive has no max limit for strings
+      case Types.TINYINT:
+      case Types.SMALLINT:
+      case Types.INTEGER:
+      case Types.BIGINT:
+        return columnPrecision(columnType) + 1; // allow +/-
+      case Types.TIMESTAMP:
+        return columnPrecision(columnType);
+      // see http://download.oracle.com/javase/6/docs/api/constant-values.html#java.lang.Float.MAX_EXPONENT
+      case Types.FLOAT:
+        return 24; // e.g. -(17#).e-###
+      // see http://download.oracle.com/javase/6/docs/api/constant-values.html#java.lang.Double.MAX_EXPONENT
+      case Types.DOUBLE:
+        return 25; // e.g. -(17#).e-####
+      case Types.DECIMAL:
+        return Integer.MAX_VALUE;
+      default:
+        throw new SQLException("Invalid column type: " + columnType);
+    }
+  }
+
+  static int columnPrecision(int columnType) throws SQLException {
+    // according to hiveTypeToSqlType possible options are:
+    switch(columnType) {
+      case Types.BOOLEAN:
+        return 1;
+      case Types.VARCHAR:
+        return Integer.MAX_VALUE; // hive has no max limit for strings
+      case Types.TINYINT:
+        return 3;
+      case Types.SMALLINT:
+        return 5;
+      case Types.INTEGER:
+        return 10;
+      case Types.BIGINT:
+        return 19;
+      case Types.FLOAT:
+        return 7;
+      case Types.DOUBLE:
+        return 15;
+      case Types.TIMESTAMP:
+        return 29;
+      case Types.DECIMAL:
+        return Integer.MAX_VALUE;
+      default:
+        throw new SQLException("Invalid column type: " + columnType);
+    }
+  }
+
+  static int columnScale(int columnType) throws SQLException {
+    // according to hiveTypeToSqlType possible options are:
+    switch(columnType) {
+      case Types.BOOLEAN:
+      case Types.VARCHAR:
+      case Types.TINYINT:
+      case Types.SMALLINT:
+      case Types.INTEGER:
+      case Types.BIGINT:
+        return 0;
+      case Types.FLOAT:
+        return 7;
+      case Types.DOUBLE:
+        return 15;
+      case Types.TIMESTAMP:
+        return 9;
+      case Types.DECIMAL:
+        return Integer.MAX_VALUE;
+      default:
+        throw new SQLException("Invalid column type: " + columnType);
+    }
+  }
+
+  public Logger getParentLogger() throws SQLFeatureNotSupportedException {
+    // JDK 1.7
+    throw new SQLFeatureNotSupportedException("getParentLogger not supported");
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/342fd47f/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoMetaDataResultSet.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoMetaDataResultSet.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoMetaDataResultSet.java
new file mode 100644
index 0000000..1e75424
--- /dev/null
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoMetaDataResultSet.java
@@ -0,0 +1,77 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.tajo.jdbc;
+
+import org.apache.tajo.catalog.Schema;
+import org.apache.tajo.common.TajoDataTypes.Type;
+import org.apache.tajo.datum.Datum;
+import org.apache.tajo.storage.Tuple;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.List;
+
+public class TajoMetaDataResultSet extends TajoResultSetBase {
+  private List<MetaDataTuple> values;
+
+  public TajoMetaDataResultSet(List<String> columns, List<Type> types, List<MetaDataTuple> values) {
+    init();
+    schema = new Schema();
+
+    int index = 0;
+    if(columns != null) {
+      for(String columnName: columns) {
+        schema.addColumn(columnName, types.get(index++));
+      }
+    }
+    this.values = values;
+    totalRow = values == null ? 0 : values.size();
+  }
+
+  @Override
+  protected Tuple nextTuple() throws IOException {
+    if(curRow >= totalRow) {
+      return null;
+    }
+    return values.get(curRow);
+  }
+
+  @Override
+  public void close() throws SQLException {
+  }
+
+  @Override
+  public String getString(int fieldId) throws SQLException {
+    Datum datum = cur.get(fieldId - 1);
+    if(datum == null) {
+      return null;
+    }
+
+    return datum.asChars();
+  }
+
+  @Override
+  public String getString(String name) throws SQLException {
+    Datum datum = cur.get(findColumn(name));
+    if(datum == null) {
+      return null;
+    }
+    return datum.asChars();
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/342fd47f/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoPreparedStatement.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoPreparedStatement.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoPreparedStatement.java
new file mode 100644
index 0000000..a6e3bbf
--- /dev/null
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoPreparedStatement.java
@@ -0,0 +1,660 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.tajo.jdbc;
+
+import org.apache.tajo.client.TajoClient;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.*;
+import java.util.Calendar;
+import java.util.HashMap;
+
+/**
+ * TajoPreparedStatement.
+ *
+ */
+public class TajoPreparedStatement implements PreparedStatement {
+  private final String sql;
+  private TajoClient tajoClient;
+  /**
+   * save the SQL parameters {paramLoc:paramValue}
+   */
+  private final HashMap<Integer, String> parameters=new HashMap<Integer, String>();
+
+  /**
+   * We need to keep a reference to the result set to support the following:
+   * <code>
+   * statement.execute(String sql);
+   * statement.getResultSet();
+   * </code>.
+   */
+  private ResultSet resultSet = null;
+
+  /**
+   * Add SQLWarnings to the warningChain if needed.
+   */
+  private  SQLWarning warningChain = null;
+
+  /**
+   * Keep state so we can fail certain calls made after close().
+   */
+  private boolean isClosed = false;
+
+  /**
+   * keep the current ResultRet update count
+   */
+  private final int updateCount = 0;
+
+  /**
+   *
+   */
+  public TajoPreparedStatement(TajoClient tajoClient,
+                               String sql) {
+    this.tajoClient = tajoClient;
+    this.sql = sql;
+  }
+
+  @Override
+  public void addBatch() throws SQLException {
+    throw new SQLFeatureNotSupportedException("addBatch");
+  }
+
+  @Override
+  public void clearParameters() throws SQLException {
+    this.parameters.clear();
+  }
+
+  @Override
+  public boolean execute() throws SQLException {
+    ResultSet rs = executeImmediate(sql);
+    return rs != null;
+  }
+
+  @Override
+  public ResultSet executeQuery() throws SQLException {
+    return executeImmediate(sql);
+  }
+
+  @Override
+  public int executeUpdate() throws SQLException {
+    executeImmediate(sql);
+    return updateCount;
+  }
+
+  protected ResultSet executeImmediate(String sql) throws SQLException {
+    if (isClosed) {
+      throw new SQLFeatureNotSupportedException("Can't execute after statement has been closed");
+    }
+
+    try {
+      if (sql.contains("?")) {
+        sql = updateSql(sql, parameters);
+      }
+      resultSet = tajoClient.executeQueryAndGetResult(sql);
+    } catch (Exception e) {
+      throw new SQLFeatureNotSupportedException(e.getMessage(), e);
+    }
+    return resultSet;
+  }
+
+  /**
+   * update the SQL string with parameters set by setXXX methods of {@link java.sql.PreparedStatement}
+   *
+   * @param sql
+   * @param parameters
+   * @return updated SQL string
+   */
+  private String updateSql(final String sql, HashMap<Integer, String> parameters) {
+
+    StringBuffer newSql = new StringBuffer(sql);
+
+    int paramLoc = 1;
+    while (getCharIndexFromSqlByParamLocation(sql, '?', paramLoc) > 0) {
+      // check the user has set the needs parameters
+      if (parameters.containsKey(paramLoc)) {
+        int tt = getCharIndexFromSqlByParamLocation(newSql.toString(), '?', 1);
+        newSql.deleteCharAt(tt);
+        newSql.insert(tt, parameters.get(paramLoc));
+      }
+      paramLoc++;
+    }
+
+    return newSql.toString();
+
+  }
+
+  /**
+   * Get the index of given char from the SQL string by parameter location
+   * </br> The -1 will be return, if nothing found
+   *
+   * @param sql
+   * @param cchar
+   * @param paramLoc
+   * @return
+   */
+  private int getCharIndexFromSqlByParamLocation(final String sql, final char cchar, final int paramLoc) {
+    int signalCount = 0;
+    int charIndex = -1;
+    int num = 0;
+    for (int i = 0; i < sql.length(); i++) {
+      char c = sql.charAt(i);
+      if (c == '\'' || c == '\\')// record the count of char "'" and char "\"
+      {
+        signalCount++;
+      } else if (c == cchar && signalCount % 2 == 0) {// check if the ? is really the parameter
+        num++;
+        if (num == paramLoc) {
+          charIndex = i;
+          break;
+        }
+      }
+    }
+    return charIndex;
+  }
+
+  @Override
+  public ResultSetMetaData getMetaData() throws SQLException {
+    if(resultSet != null) {
+      return resultSet.getMetaData();
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public ParameterMetaData getParameterMetaData() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getParameterMetaData not supported");
+  }
+
+  @Override
+  public void setArray(int i, Array x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setArray not supported");
+  }
+
+  @Override
+  public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setAsciiStream not supported");
+  }
+
+  @Override
+  public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setAsciiStream not supported");
+  }
+
+  @Override
+  public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setAsciiStream not supported");
+  }
+
+  @Override
+  public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBigDecimal not supported");
+  }
+
+  @Override
+  public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBinaryStream not supported");
+  }
+
+  @Override
+  public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBinaryStream not supported");
+  }
+
+  @Override
+  public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBinaryStream not supported");
+  }
+
+  @Override
+  public void setBlob(int i, Blob x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBlob not supported");
+  }
+
+  @Override
+  public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBlob not supported");
+  }
+
+  @Override
+  public void setBlob(int parameterIndex, InputStream inputStream, long length)
+          throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBlob not supported");
+  }
+
+  @Override
+  public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+    this.parameters.put(parameterIndex, "" + x);
+  }
+
+  @Override
+  public void setByte(int parameterIndex, byte x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setByte not supported");
+  }
+
+  @Override
+  public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setBytes not supported");
+  }
+
+  @Override
+  public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setCharacterStream not supported");
+  }
+
+  @Override
+  public void setCharacterStream(int parameterIndex, Reader reader, int length)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("setCharacterStream not supported");
+  }
+
+  @Override
+  public void setCharacterStream(int parameterIndex, Reader reader, long length)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("setCharacterStream not supported");
+  }
+
+  @Override
+  public void setClob(int i, Clob x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setClob not supported");
+  }
+
+  @Override
+  public void setClob(int parameterIndex, Reader reader) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setClob not supported");
+  }
+
+  @Override
+  public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setClob not supported");
+  }
+
+  @Override
+  public void setDate(int parameterIndex, Date x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setDate not supported");
+  }
+
+  @Override
+  public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setDate not supported");
+  }
+
+  @Override
+  public void setDouble(int parameterIndex, double x) throws SQLException {
+    this.parameters.put(parameterIndex,"" + x);
+  }
+
+  @Override
+  public void setFloat(int parameterIndex, float x) throws SQLException {
+    this.parameters.put(parameterIndex,"" + x);
+  }
+
+  @Override
+  public void setInt(int parameterIndex, int x) throws SQLException {
+    this.parameters.put(parameterIndex,"" + x);
+  }
+
+  @Override
+  public void setLong(int parameterIndex, long x) throws SQLException {
+    this.parameters.put(parameterIndex,"" + x);
+  }
+
+  @Override
+  public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNCharacterStream not supported");
+  }
+
+  @Override
+  public void setNCharacterStream(int parameterIndex, Reader value, long length)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNCharacterStream not supported");
+  }
+
+  @Override
+  public void setNClob(int parameterIndex, NClob value) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNClob not supported");
+  }
+
+  @Override
+  public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNClob not supported");
+  }
+
+  @Override
+  public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNClob not supported");
+  }
+
+  @Override
+  public void setNString(int parameterIndex, String value) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNString not supported");
+  }
+
+  @Override
+  public void setNull(int parameterIndex, int sqlType) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNull not supported");
+  }
+
+  @Override
+  public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setNull not supported");
+  }
+
+  @Override
+  public void setObject(int parameterIndex, Object x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setObject not supported");
+  }
+
+  @Override
+  public void setObject(int parameterIndex, Object x, int targetSqlType)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("setObject not supported");
+  }
+
+  @Override
+  public void setObject(int parameterIndex, Object x, int targetSqlType, int scale)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("setObject not supported");
+  }
+
+  @Override
+  public void setRef(int i, Ref x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setRef not supported");
+  }
+
+  @Override
+  public void setRowId(int parameterIndex, RowId x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setRowId not supported");
+  }
+
+  @Override
+  public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setSQLXML not supported");
+  }
+
+  @Override
+  public void setShort(int parameterIndex, short x) throws SQLException {
+    this.parameters.put(parameterIndex,"" + x);
+  }
+
+  @Override
+  public void setString(int parameterIndex, String x) throws SQLException {
+     x=x.replace("'", "\\'");
+     this.parameters.put(parameterIndex,"'" + x +"'");
+  }
+
+  @Override
+  public void setTime(int parameterIndex, Time x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setTime not supported");
+  }
+
+  @Override
+  public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setTime not supported");
+  }
+
+  @Override
+  public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setTimestamp not supported");
+  }
+
+  @Override
+  public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("setTimestamp not supported");
+  }
+
+  @Override
+  public void setURL(int parameterIndex, URL x) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setURL not supported");
+  }
+
+  @Override
+  public void setUnicodeStream(int parameterIndex, InputStream x, int length)
+      throws SQLException {
+    throw new SQLFeatureNotSupportedException("setUnicodeStream not supported");
+  }
+
+  @Override
+  public void addBatch(String sql) throws SQLException {
+    throw new SQLFeatureNotSupportedException("addBatch not supported");
+  }
+
+  @Override
+  public void cancel() throws SQLException {
+    throw new SQLFeatureNotSupportedException("cancel not supported");
+  }
+
+  @Override
+  public void clearBatch() throws SQLException {
+    throw new SQLFeatureNotSupportedException("clearBatch not supported");
+  }
+
+  @Override
+  public void clearWarnings() throws SQLException {
+     warningChain=null;
+  }
+
+  public void closeOnCompletion() throws SQLException {
+    // JDK 1.7
+    throw new SQLFeatureNotSupportedException("closeOnCompletion");
+  }
+
+  @Override
+  public void close() throws SQLException {
+    if (resultSet!=null) {
+      resultSet.close();
+      resultSet = null;
+    }
+    isClosed = true;
+  }
+
+  @Override
+  public boolean execute(String sql) throws SQLException {
+    throw new SQLFeatureNotSupportedException("execute(sql) not supported");
+  }
+
+  @Override
+  public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
+    throw new SQLFeatureNotSupportedException("execute(sql) not supported");
+  }
+
+  @Override
+  public boolean execute(String sql, int[] columnIndexes) throws SQLException {
+    throw new SQLFeatureNotSupportedException("execute(sql) not supported");
+  }
+
+  @Override
+  public boolean execute(String sql, String[] columnNames) throws SQLException {
+    throw new SQLFeatureNotSupportedException("execute(sql) not supported");
+  }
+
+  @Override
+  public int[] executeBatch() throws SQLException {
+    throw new SQLFeatureNotSupportedException("executeBatch not supported");
+  }
+
+  @Override
+  public ResultSet executeQuery(String sql) throws SQLException {
+    throw new SQLFeatureNotSupportedException("executeQuery(sql) not supported");
+  }
+
+  @Override
+  public int executeUpdate(String sql) throws SQLException {
+    throw new SQLFeatureNotSupportedException("executeUpdate not supported");
+  }
+
+  @Override
+  public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
+    throw new SQLFeatureNotSupportedException("executeUpdate not supported");
+  }
+
+  @Override
+  public int executeUpdate(String sql, int[] columnIndexes) throws SQLException {
+    throw new SQLFeatureNotSupportedException("executeUpdate not supported");
+  }
+
+  @Override
+  public int executeUpdate(String sql, String[] columnNames) throws SQLException {
+    throw new SQLFeatureNotSupportedException("executeUpdate not supported");
+  }
+
+  @Override
+  public Connection getConnection() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getConnection not supported");
+  }
+
+  @Override
+  public int getFetchDirection() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getFetchDirection not supported");
+  }
+
+  @Override
+  public int getFetchSize() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getFetchSize not supported");
+  }
+
+  @Override
+  public ResultSet getGeneratedKeys() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getGeneratedKeys not supported");
+  }
+
+  @Override
+  public int getMaxFieldSize() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxFieldSize not supported");
+  }
+
+  @Override
+  public int getMaxRows() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMaxRows not supported");
+  }
+
+  @Override
+  public boolean getMoreResults() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMoreResults not supported");
+  }
+
+  @Override
+  public boolean getMoreResults(int current) throws SQLException {
+    throw new SQLFeatureNotSupportedException("getMoreResults not supported");
+  }
+
+  @Override
+  public int getQueryTimeout() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getQueryTimeout not supported");
+  }
+
+  @Override
+  public ResultSet getResultSet() throws SQLException {
+    return this.resultSet;
+  }
+
+  @Override
+  public int getResultSetConcurrency() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getResultSetConcurrency not supported");
+  }
+
+  @Override
+  public int getResultSetHoldability() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getResultSetHoldability not supported");
+  }
+
+  @Override
+  public int getResultSetType() throws SQLException {
+    throw new SQLFeatureNotSupportedException("getResultSetType not supported");
+  }
+
+  @Override
+  public int getUpdateCount() throws SQLException {
+    return updateCount;
+  }
+
+  @Override
+  public SQLWarning getWarnings() throws SQLException {
+    return warningChain;
+  }
+
+  @Override
+  public boolean isClosed() throws SQLException {
+    return isClosed;
+  }
+
+   public boolean isCloseOnCompletion() throws SQLException {
+     //JDK 1.7
+     throw new SQLFeatureNotSupportedException("isCloseOnCompletion not supported");
+   }
+
+  @Override
+  public boolean isPoolable() throws SQLException {
+    throw new SQLFeatureNotSupportedException("isPoolable not supported");
+  }
+
+  @Override
+  public void setCursorName(String name) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setCursorName not supported");
+  }
+
+  @Override
+  public void setEscapeProcessing(boolean enable) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setEscapeProcessing not supported");
+  }
+
+  @Override
+  public void setFetchDirection(int direction) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setFetchDirection not supported");
+  }
+
+  @Override
+  public void setFetchSize(int rows) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setFetchSize not supported");
+  }
+
+  @Override
+  public void setMaxFieldSize(int max) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setMaxFieldSize not supported");
+  }
+
+  @Override
+  public void setMaxRows(int max) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setMaxRows not supported");
+  }
+
+  @Override
+  public void setPoolable(boolean poolable) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setPoolable not supported");
+  }
+
+  @Override
+  public void setQueryTimeout(int seconds) throws SQLException {
+    throw new SQLFeatureNotSupportedException("setQueryTimeout not supported");
+  }
+
+  @Override
+  public boolean isWrapperFor(Class<?> iface) throws SQLException {
+    throw new SQLFeatureNotSupportedException("isWrapperFor not supported");
+  }
+
+  @Override
+  public <T> T unwrap(Class<T> iface) throws SQLException {
+    throw new SQLFeatureNotSupportedException("unwrap not supported");
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/342fd47f/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoResultSet.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoResultSet.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoResultSet.java
new file mode 100644
index 0000000..a50ed2c
--- /dev/null
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/jdbc/TajoResultSet.java
@@ -0,0 +1,150 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.tajo.jdbc;
+
+import com.google.common.collect.Lists;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.fs.PathFilter;
+import org.apache.tajo.QueryId;
+import org.apache.tajo.catalog.TableDesc;
+import org.apache.tajo.catalog.TableMeta;
+import org.apache.tajo.client.TajoClient;
+import org.apache.tajo.storage.MergeScanner;
+import org.apache.tajo.storage.Scanner;
+import org.apache.tajo.storage.Tuple;
+import org.apache.tajo.storage.fragment.FileFragment;
+
+import java.io.IOException;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+
+public class TajoResultSet extends TajoResultSetBase {
+  private FileSystem fs;
+  private Scanner scanner;
+  private TajoClient tajoClient;
+  QueryId queryId;
+
+  public TajoResultSet(TajoClient tajoClient, QueryId queryId) {
+    this.tajoClient = tajoClient;
+    this.queryId = queryId;
+    init();
+  }
+
+  public TajoResultSet(TajoClient tajoClient, QueryId queryId,
+                       Configuration conf, TableDesc desc) throws IOException {
+    this.schema = desc.getSchema();
+    this.tajoClient = tajoClient;
+    this.queryId = queryId;
+    if(desc != null) {
+      fs = desc.getPath().getFileSystem(conf);
+      this.totalRow = desc.getStats() != null ? desc.getStats().getNumRows() : 0;
+
+      Collection<FileFragment> frags = getFragments(desc.getMeta(), desc.getPath());
+      scanner = new MergeScanner(conf, schema, desc.getMeta(), frags);
+    }
+    init();
+  }
+
+  @Override
+  protected void init() {
+    cur = null;
+    curRow = 0;
+  }
+
+  class FileNameComparator implements Comparator<FileStatus> {
+
+    @Override
+    public int compare(FileStatus f1, FileStatus f2) {
+      return f2.getPath().getName().compareTo(f1.getPath().getName());
+    }
+  }
+
+  private Collection<FileFragment> getFragments(TableMeta meta, Path tablePath)
+      throws IOException {
+    List<FileFragment> fraglist = Lists.newArrayList();
+    FileStatus[] files = fs.listStatus(tablePath, new PathFilter() {
+      @Override
+      public boolean accept(Path path) {
+        return path.getName().charAt(0) != '.';
+      }
+    });
+    Arrays.sort(files, new FileNameComparator());
+
+    String tbname = tablePath.getName();
+    for (int i = 0; i < files.length; i++) {
+      if (files[i].getLen() == 0) {
+        continue;
+      }
+      fraglist.add(new FileFragment(tbname + "_" + i, files[i].getPath(), 0l, files[i].getLen()));
+    }
+    return fraglist;
+  }
+
+  @Override
+  public void close() throws SQLException {
+    try {
+      if(tajoClient != null) {
+        this.tajoClient.closeQuery(queryId);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    try {
+      if(scanner != null) {
+        this.scanner.close();
+      }
+      //TODO clean temp result file
+      cur = null;
+      curRow = -1;
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  @Override
+  public void beforeFirst() throws SQLException {
+    try {
+      if(scanner != null) {
+        scanner.reset();
+      }
+      init();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+
+  @Override
+  protected Tuple nextTuple() throws IOException {
+    if(scanner == null) {
+      return null;
+    }
+    return scanner.next();
+  }
+
+  public boolean hasResult() {
+    return scanner != null;
+  }
+}


Mime
View raw message