/** * @deprecated Use {@link DatabaseStructure#foreignTablesFor(String)} instead, since it provides a cleaner API */ public static List<String> getForeignTables(SQLiteDatabase db, String table) { return new DatabaseStructure(db).foreignTablesFor(table); }
/** * @deprecated Use {@link DatabaseStructure#columnsFor(String)} instead, since it provides a cleaner API */ @Deprecated public static Map<String, SQLiteType> getFields(SQLiteDatabase db, String table) { return new DatabaseStructure(db).columnsFor(table); }
/** * @deprecated Use {@link DatabaseStructure#projectionMap(String, String...)} instead, since it provides a cleaner API */ @Deprecated public static Map<String, String> getProjectionMap(SQLiteDatabase db, String parent, String... foreignTables) { return new DatabaseStructure(db).projectionMap(parent, foreignTables); }
/** * @deprecated Use {@link DatabaseStructure#uniqueConstraintsFor(String)} instead, since it provides a cleaner API */ @Deprecated public static List<Constraint> getUniqueConstraints(SQLiteDatabase db, String table) { return new DatabaseStructure(db).uniqueConstraintsFor(table); }
/** * @deprecated Use {@link DatabaseStructure#tables()} instead * * @param db the database to get meta information from * @return a list of tables */ @Deprecated public static List<String> getTables(SQLiteDatabase db) { return new DatabaseStructure(db).tables(); }
public List<String> foreignTablesFor(String table) { Cursor columnsCursor = queryTableColumnsFor(table); List<String> allTables = tables(); List<String> foreignTables = parseForeignTablesFor(columnsCursor, allTables); columnsCursor.close(); return Collections.unmodifiableList(foreignTables); }
public Map<String, String> projectionMap(String parent, String... foreignTables) { Map<String, String> projection = new TreeMap<>(); projection.put("_id", parent + "._id AS _id"); projection.putAll(projectionFor(parent, columnsFor(parent))); projection.putAll(projectionForEach(foreignTables)); return Collections.unmodifiableMap(projection); }
public void testEmptyUniqueConstraints() { createDatabase(CREATE_TABLES); List<Constraint> constraints = databaseStructure.uniqueConstraintsFor("t"); assertEmpty(constraints); }
private Map<String, String> projectionForEach(String... foreignTables) { Map<String, String> projection = new TreeMap<>(); for (String ft : foreignTables) { projection.putAll(projectionFor(ft, columnsFor(ft))); } return projection; }
public List<Constraint> uniqueConstraintsFor(String table) { List<Constraint> uniqueConstraints = new ArrayList<>(); Constraint implicitIntegerPrimaryKeyConstraint = implicitIntegerPrimaryKeyConstraint(table); if (implicitIntegerPrimaryKeyConstraint != null) { uniqueConstraints.add(implicitIntegerPrimaryKeyConstraint); } Cursor indexCursor = queryIndexListFor(table); uniqueConstraints.addAll(parseUniqueConstraintsFrom(indexCursor)); indexCursor.close(); return Collections.unmodifiableList(uniqueConstraints); }
public void testColumns() { createDatabase(CREATE_TABLES); Map<String, SQLiteType> columns = databaseStructure.columnsFor("t1"); assertContentsInAnyOrder(columns.keySet(), "id", "name", "r"); }
public void testTables() { createDatabase(CREATE_2_TABLES); List<String> tables = databaseStructure.tables(); assertContentsInAnyOrder(tables, "T", "T2"); }
public void testProjectionMap() { createDatabase(CREATE_2_TABLES_WITH_FOREIGN_KEY); Map<String, String> projectionMap = databaseStructure.projectionMap("t", "t2"); assertEquals("t.id AS t_id", projectionMap.get("t_id")); assertEquals("t2.id AS t2_id", projectionMap.get("t2_id")); }
public void testForeignTable() { createDatabase(CREATE_2_TABLES_WITH_FOREIGN_KEY); List<String> foreignTables = databaseStructure.foreignTablesFor("t2"); assertContentsInAnyOrder(foreignTables, "t"); }
private void createDatabase(String createSqlStatements) { createDbFromSqlStatements(getContext(), DB_NAME, 1, createSqlStatements); SQLiteDatabase db = getContext().openOrCreateDatabase(DB_NAME, 0, null); databaseStructure = new DatabaseStructure(db); } }
private Constraint parseIntegerPrimaryKeyConstraintFrom(Cursor columnsCursor) { Constraint integerPrimaryKeyConstraint = null; while (columnsCursor.moveToNext() && integerPrimaryKeyConstraint == null) { integerPrimaryKeyConstraint = extractIntegerPrimaryKeyConstraintFrom(columnsCursor); } return integerPrimaryKeyConstraint; }
private String foreignTableFor(String columnName, List<String> tables) { if (!isForeignKey(columnName)) { return null; } String tableName = columnName.substring(0, columnName.lastIndexOf('_')); if (tables.contains(tableName + "s")) { return (tableName + "s"); } else if (tables.contains(tableName)) { return (tableName); } return null; }
private List<String> parseForeignTablesFor(Cursor columnsCursor, List<String> allTables) { List<String> foreignTables = new ArrayList<>(); while (columnsCursor.moveToNext()) { String columnName = columnsCursor.getString(columnsCursor.getColumnIndexOrThrow(COLUMN_NAME)); String foreignTable = foreignTableFor(columnName, allTables); if (foreignTable != null) { foreignTables.add(foreignTable); } } return foreignTables; }
public void testUniqueConstraints() { createDatabase(CREATE_TABLE_WITH_CONSTRAINT); List<Constraint> constraints = databaseStructure.uniqueConstraintsFor("t"); assertContentsInAnyOrder(constraints, new Constraint(Collections.singletonList("const"))); }
public void testUniqueConstraintsForIntegerPrimaryKey() { createDatabase(CREATE_TABLE_WITH_INTEGER_PRIMARY_KEY); List<Constraint> constraints = databaseStructure.uniqueConstraintsFor("t"); assertContentsInAnyOrder(constraints, new Constraint(Collections.singletonList("_id"))); }