This week, Andrew Jefford looks at Virginia's classic grape varieties, and how they compare to their European counterparts, plus he tastes eight wines.
{"content":"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"}