content: /*
   * 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.calcite.avatica;
  
  import org.apache.calcite.avatica.remote.MetaDataOperation;
  
  import org.junit.Before;
  import org.junit.Test;
  import org.mockito.Mockito;
  
  import java.sql.Connection;
  import java.sql.DatabaseMetaData;
  import java.sql.ResultSet;
  import java.sql.Statement;
  
  import static org.junit.Assert.assertEquals;
  
  /**
   * Tests that {@link QueryState} properly retains the necessary state to recreate
   * a {@link ResultSet}.
   */
  public class QueryStateTest {
  
    private Connection conn;
    private DatabaseMetaData metadata;
    private Statement statement;
  
  
    @Before
    public void setup() throws Exception {
      conn = Mockito.mock(Connection.class);
      metadata = Mockito.mock(DatabaseMetaData.class);
      statement = Mockito.mock(Statement.class);
  
      Mockito.when(conn.getMetaData()).thenReturn(metadata);
    }
  
    @Test
    public void testMetadataGetAttributes() throws Exception {
      final String catalog = "catalog";
      final String schemaPattern = null;
      final String typeNamePattern = "%";
      final String attributeNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_ATTRIBUTES, catalog, schemaPattern,
          typeNamePattern, attributeNamePattern);
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getAttributes(catalog, schemaPattern, typeNamePattern,
          attributeNamePattern);
    }
  
    @Test
    public void testMetadataGetBestRowIdentifier() throws Exception {
      final String catalog = "catalog";
      final String schema = null;
      final String table = "table";
      final int scope = 1;
      final boolean nullable = true;
  
      QueryState state = new QueryState(MetaDataOperation.GET_BEST_ROW_IDENTIFIER, new Object[] {
          catalog,
          schema,
          table,
          scope,
          nullable
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getBestRowIdentifier(catalog, schema, table, scope, nullable);
    }
  
    @Test
    public void testMetadataGetCatalogs() throws Exception {
      QueryState state = new QueryState(MetaDataOperation.GET_CATALOGS, new Object[0]);
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getCatalogs();
    }
  
    @Test
    public void testMetadataGetColumnPrivileges() throws Exception {
      final String catalog = null;
      final String schema = "schema";
      final String table = "table";
      final String columnNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_COLUMN_PRIVILEGES, new Object[] {
          catalog,
          schema,
          table,
          columnNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getColumnPrivileges(catalog, schema, table, columnNamePattern);
    }
  
    @Test
    public void testMetadataGetColumns() throws Exception {
      final String catalog = null;
      final String schemaPattern = "%";
      final String tableNamePattern = "%";
      final String columnNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_COLUMNS, new Object[] {
          catalog,
          schemaPattern,
          tableNamePattern,
          columnNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getColumns(catalog, schemaPattern, tableNamePattern,
          columnNamePattern);
    }
  
    @Test
    public void testMetadataGetCrossReference() throws Exception {
      final String parentCatalog = null;
      final String parentSchema = null;
      final String parentTable = "%";
      final String foreignCatalog = null;
      final String foreignSchema = null;
      final String foreignTable = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_CROSS_REFERENCE, new Object[] {
          parentCatalog,
          parentSchema,
          parentTable,
          foreignCatalog,
          foreignSchema,
          foreignTable
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getCrossReference(parentCatalog, parentSchema, parentTable,
          foreignCatalog, foreignSchema, foreignTable);
    }
  
    @Test
    public void testMetadataGetExportedKeys() throws Exception {
      final String catalog = "";
      final String schema = null;
      final String table = "mytable";
  
      QueryState state = new QueryState(MetaDataOperation.GET_EXPORTED_KEYS, new Object[] {
          catalog,
          schema,
          table
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getExportedKeys(catalog, schema, table);
    }
  
    @Test
    public void testMetadataGetFunctionColumns() throws Exception {
      final String catalog = null;
      final String schemaPattern = "%";
      final String functionNamePattern = "%";
      final String columnNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_FUNCTION_COLUMNS, new Object[] {
          catalog,
          schemaPattern,
          functionNamePattern,
          columnNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getFunctionColumns(catalog, schemaPattern, functionNamePattern,
          columnNamePattern);
    }
  
    @Test
    public void testMetadataGetFunctions() throws Exception {
      final String catalog = null;
      final String schemaPattern = "%";
      final String functionNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_FUNCTIONS, new Object[] {
          catalog,
          schemaPattern,
          functionNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getFunctions(catalog, schemaPattern, functionNamePattern);
    }
  
    @Test
    public void testMetadataGetImportedKeys() throws Exception {
      final String catalog = "";
      final String schema = null;
      final String table = "my_table";
  
      QueryState state = new QueryState(MetaDataOperation.GET_IMPORTED_KEYS, new Object[] {
          catalog,
          schema,
          table
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getImportedKeys(catalog, schema, table);
    }
  
    @Test
    public void testMetadataGetIndexInfo() throws Exception {
      final String catalog = "";
      final String schema = null;
      final String table = "my_table";
      final boolean unique = true;
      final boolean approximate = true;
  
      QueryState state = new QueryState(MetaDataOperation.GET_INDEX_INFO, new Object[] {
          catalog,
          schema,
          table,
          unique,
          approximate
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getIndexInfo(catalog, schema, table, unique, approximate);
    }
  
    @Test
    public void testMetadataGetPrimaryKeys() throws Exception {
      final String catalog = "";
      final String schema = null;
      final String table = "my_table";
  
      QueryState state = new QueryState(MetaDataOperation.GET_PRIMARY_KEYS, new Object[] {
          catalog,
          schema,
          table
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getPrimaryKeys(catalog, schema, table);
    }
  
    @Test
    public void testMetadataGetProcedureColumns() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String procedureNamePattern = "%";
      final String columnNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_PROCEDURE_COLUMNS, new Object[] {
          catalog,
          schemaPattern,
          procedureNamePattern,
          columnNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getProcedureColumns(catalog, schemaPattern, procedureNamePattern,
          columnNamePattern);
    }
  
    @Test
    public void testMetadataGetProcedures() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String procedureNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_PROCEDURES, new Object[] {
          catalog,
          schemaPattern,
          procedureNamePattern,
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getProcedures(catalog, schemaPattern, procedureNamePattern);
    }
  
    @Test
    public void testMetadataGetPseudoColumns() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String tableNamePattern = "%";
      final String columnNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_PSEUDO_COLUMNS, new Object[] {
          catalog,
          schemaPattern,
          tableNamePattern,
          columnNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getPseudoColumns(catalog, schemaPattern, tableNamePattern,
          columnNamePattern);
    }
  
    @Test
    public void testMetadataGetSchemas() throws Exception {
      QueryState state = new QueryState(MetaDataOperation.GET_SCHEMAS, new Object[0]);
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getSchemas();
    }
  
    @Test
    public void testMetadataGetSchemasWithArgs() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
  
      QueryState state = new QueryState(MetaDataOperation.GET_SCHEMAS_WITH_ARGS, new Object[] {
          catalog,
          schemaPattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getSchemas(catalog, schemaPattern);
    }
  
    @Test
    public void testMetadataGetSuperTables() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String tableNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_SUPER_TABLES, new Object[] {
          catalog,
          schemaPattern,
          tableNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getSuperTables(catalog, schemaPattern, tableNamePattern);
    }
  
    @Test
    public void testMetadataGetSuperTypes() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String tableNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_SUPER_TYPES, new Object[] {
          catalog,
          schemaPattern,
          tableNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getSuperTypes(catalog, schemaPattern, tableNamePattern);
    }
  
    @Test
    public void testMetadataGetTablePrivileges() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String tableNamePattern = "%";
  
      QueryState state = new QueryState(MetaDataOperation.GET_TABLE_PRIVILEGES, new Object[] {
          catalog,
          schemaPattern,
          tableNamePattern
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getTablePrivileges(catalog, schemaPattern, tableNamePattern);
    }
  
    @Test
    public void testMetadataGetTables() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String tableNamePattern = "%";
      final String[] types = new String[] {"VIEW", "TABLE"};
  
      QueryState state = new QueryState(MetaDataOperation.GET_TABLES, new Object[] {
          catalog,
          schemaPattern,
          tableNamePattern,
          types
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getTables(catalog, schemaPattern, tableNamePattern, types);
    }
  
    @Test
    public void testMetadataGetTableTypes() throws Exception {
      QueryState state = new QueryState(MetaDataOperation.GET_TABLE_TYPES, new Object[0]);
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getTableTypes();
    }
  
    @Test
    public void testMetadataGetTypeInfo() throws Exception {
      QueryState state = new QueryState(MetaDataOperation.GET_TYPE_INFO, new Object[0]);
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getTypeInfo();
    }
  
    @Test
    public void testMetadataGetUDTs() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String typeNamePattern = "%";
      final int[] types = new int[] {1, 2};
  
      QueryState state = new QueryState(MetaDataOperation.GET_UDTS, new Object[] {
          catalog,
          schemaPattern,
          typeNamePattern,
          types
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getUDTs(catalog, schemaPattern, typeNamePattern, types);
    }
  
    @Test
    public void testMetadataGetVersionColumns() throws Exception {
      final String catalog = "";
      final String schemaPattern = null;
      final String table = "my_table";
  
      QueryState state = new QueryState(MetaDataOperation.GET_VERSION_COLUMNS, new Object[] {
          catalog,
          schemaPattern,
          table
      });
  
      state.invoke(conn, statement);
  
      Mockito.verify(metadata).getVersionColumns(catalog, schemaPattern, table);
    }
  
    @Test
    public void testSerialization() throws Exception {
      final String catalog = "catalog";
      final String schema = null;
      final String table = "table";
      final int scope = 1;
      final boolean nullable = true;
  
      QueryState state = new QueryState(MetaDataOperation.GET_BEST_ROW_IDENTIFIER, new Object[] {
          catalog,
          schema,
          table,
          scope,
          nullable
      });
  
      assertEquals(state, QueryState.fromProto(state.toProto()));
  
      final String schemaPattern = null;
      final String typeNamePattern = "%";
      final int[] types = new int[] {1, 2};
  
      state = new QueryState(MetaDataOperation.GET_UDTS, new Object[] {
          catalog,
          schemaPattern,
          typeNamePattern,
          types
      });
  
      assertEquals(state, QueryState.fromProto(state.toProto()));
  
      state = new QueryState("SELECT * FROM foo");
  
      assertEquals(state, QueryState.fromProto(state.toProto()));
    }
  
  }
  
  // End QueryStateTest.java
  