WIP-pyshapelib-bramz/test/postgissupport.py

# Copyright (C) 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Support module for tests that use a live PostGIS database"""

__version__ = "$Revision$"
# $Source$
# $Id$

import sys
import os
import time
import popen2
import shutil
import traceback

import support

try:
    import psycopg
except ImportError:
    psycopg = None

#
#       Helper code
#

def run_config_script(cmdline):
    """Run command cmdline and return its stdout or none in case of errors"""
    pipe = os.popen(cmdline)
    result = pipe.read()
    if pipe.close() is not None:
        raise RuntimeError('Command %r failed' % cmdline)
    return result

def run_command(command, outfilename = None):
    """Run command as a subprocess and send its stdout and stderr to outfile

    The subprocess is run synchroneously so the function returns once
    the subprocess has termninated. If the process' exit code is not
    zero raise a RuntimeError.

    If outfilename is None stdout and stderr are still captured but they
    are ignored and not written to any file.
    """
    proc = popen2.Popen4(command)
    proc.tochild.close()
    output = proc.fromchild.read()
    status = proc.wait()
    if outfilename is not None:
        outfile = open(outfilename, "w")
        outfile.write(output)
        outfile.close()
    if not os.WIFEXITED(status) or os.WEXITSTATUS(status) != 0:
        if outfilename:
            message = "see %s" % outfilename
        else:
            message = output
        raise RuntimeError("command %r exited with code %d.\n%s"
                           % (command, status, message))


def run_boolean_command(command):
    """
    Run command as a subprocess silently and return whether it ran successfully

    Silently means that all output is captured and ignored. The exit
    status is true if the command ran successfull, i.e. it terminated by
    exiting and returned as zero exit code and false other wise
    """
    try:
        run_command(command, None)
        return 1
    except RuntimeError:
        pass
    return 0


#
#       PostgreSQL and database
#

class PostgreSQLServer:

    """A PostgreSQL server

    Instances of this class represent a PostgreSQL server with postgis
    extensions run explicitly for the test cases. Such a server has its
    own database directory and its own directory for the unix sockets so
    that it doesn't interfere with any other PostgreSQL server already
    running on the system.
    """

    def __init__(self, dbdir, port, postgis_sql, socket_dir):
        """Initialize the PostgreSQLServer object

        Parameters:

          dbdir -- The directory for the databases
          port -- The port to use
          postgis_sql -- The name of the file with the SQL statements to
                         initialize a database for postgis.
          socket_dir -- The directory for the socket files.

        When connecting to the database server use the port and host
        instance variables.
        """
        self.dbdir = dbdir
        self.port = port
        self.postgis_sql = postgis_sql
        self.socket_dir = socket_dir

        # For the client side the socket directory can be used as the
        # host the name starts with a slash.
        self.host = os.path.abspath(socket_dir)

        # Map db names to db objects
        self.known_dbs = {}

    def createdb(self):
        """Create the database in dbdir and start the server.

        First check whether the dbdir already exists and if necessary
        stop an already running postmaster and remove the dbdir
        directory completely. Then create a new database cluster in the
        dbdir and start a postmaster.
        """
        if os.path.isdir(self.dbdir):
            if self.is_running():
                self.shutdown()
            shutil.rmtree(self.dbdir)
        os.mkdir(self.dbdir)

        run_command(["initdb", self.dbdir],
                    os.path.join(self.dbdir, "initdb.log"))

        extra_opts = "-p %d" % self.port
        if self.socket_dir is not None:
            extra_opts += " -k %s" % self.socket_dir
        run_command(["pg_ctl", "-D", self.dbdir,
                     "-l", os.path.join(self.dbdir, "logfile"),
                     "-o", extra_opts, "start"],
                    os.path.join(self.dbdir, "pg_ctl-start.log"))
        # the -w option of pg_ctl doesn't work properly when the port is
        # not the default port, so we have to implement waiting for the
        # server ourselves
        self.wait_for_postmaster()

    def wait_for_postmaster(self):
        """Return when the database server is running

        Internal method to wait until the postmaster process has been
        started and is ready for client connections.
        """
        max_count = 60
        count = 0
        while count < max_count:
            try:
                run_command(["psql", "-l", "-p", str(self.port),
                             "-h", self.host],
                            os.path.join(self.dbdir, "psql-%d.log" % count))
            except:
                pass
            else:
                break
            time.sleep(0.5)
            count += 1
        else:
            raise RuntimeError("postmaster didn't start")

    def is_running(self):
        """Return true a postmaster process is running on self.dbdir

        This method runs pg_ctl status on the dbdir so even if the
        object has just been created it is possible that this method
        returns true if there's still a postmaster process running for
        self.dbdir.
        """
        return run_boolean_command(["pg_ctl", "-D", self.dbdir, "status"])

    def shutdown(self):
        """Stop the postmaster running for self.dbdir"""
        run_command(["pg_ctl", "-m", "fast", "-D", self.dbdir, "stop"],
                    os.path.join(self.dbdir, "pg_ctl-stop.log"))

    def new_postgis_db(self, dbname, tables = None):
        """Create and return a new PostGISDatabase object using self as server
        """
        db = PostGISDatabase(self, self.postgis_sql, dbname, tables = tables)
        db.initdb()
        self.known_dbs[dbname] = db
        return db

    def get_static_data_db(self, dbname, tables):
        """Return a PostGISDatabase for a database with the given static data

        If no databasse of the name dbname exists, create a new one via
        new_postgis_db and upload the data.

        If a database of the name dbname already exists and uses the
        indicated data, return that. If the already existing db uses
        different data raise a value error.

        The tables argument should be a sequence of table specifications
        where each specifications is a (tablename, shapefilename) pair.
        """
        db = self.known_dbs.get(dbname)
        if db is not None:
            if db.has_data(tables):
                return db
            raise ValueError("PostGISDatabase named %r doesn't have tables %r"
                             % (dbname, tables))
        return self.new_postgis_db(dbname, tables)

    def get_default_static_data_db(self):
        dbname = "PostGISStaticTests"
        tables = [("landmarks", os.path.join("..", "Data", "iceland",
                                             "cultural_landmark-point.shp")),
                  ("political", os.path.join("..", "Data", "iceland",
                                             "political.shp")),
                  ("roads", os.path.join("..", "Data", "iceland",
                                         "roads-line.shp"))]
        return self.get_static_data_db(dbname, tables)


class PostGISDatabase:

    """A PostGIS database in a PostgreSQLServer"""

    def __init__(self, server, postgis_sql, dbname, tables = None):
        self.server = server
        self.postgis_sql = postgis_sql
        self.dbname = dbname
        self.tables = tables

    def initdb(self):
        """Remove the old db directory and create and initialize a new database
        """
        run_command(["createdb", "-p", str(self.server.port),
                     "-h", self.server.host, self.dbname],
                    os.path.join(self.server.dbdir, "createdb.log"))
        run_command(["createlang", "-p", str(self.server.port),
                     "-h", self.server.host, "plpgsql", self.dbname],
                    os.path.join(self.server.dbdir, "createlang.log"))
        # for some reason psql doesn't exit with an error code if the
        # file given as -f doesn't exist, so we check manually by trying
        # to open it before we run psql
        f = open(self.postgis_sql)
        f.close()
        del f
        run_command(["psql", "-f", self.postgis_sql, "-d", self.dbname,
                     "-p", str(self.server.port), "-h", self.server.host],
                     os.path.join(self.server.dbdir, "psql.log"))

        if self.tables is not None:
            for tablename, shapefile in self.tables:
                upload_shapefile(shapefile, self, tablename)

    def has_data(self, tables):
        return self.tables == tables


def find_postgis_sql():
    """Return the name of the postgis_sql file

    A postgis installation usually has the postgis_sql file in
    PostgreSQL's datadir (i.e. the directory where PostgreSQL keeps
    static files, not the directory containing the databases).
    Unfortunately there's no way to determine the name of this directory
    with pg_config so we assume here that it's
    $bindir/../share/postgresql/.
    """
    bindir = run_config_script("pg_config --bindir").strip()
    return os.path.join(bindir, "..", "share", "postgresql",
                        "contrib", "postgis.sql")

_postgres_server = None
def get_test_server():
    """Return the test database server object.

    If it doesn't exist yet, create it first.

    The server will use the directory postgis under the temp dir (as
    defined by support.create_temp_dir()) for the database cluster.
    Sockets will be created in tempdir.
    """
    global _postgres_server
    if _postgres_server is None:
        tempdir = support.create_temp_dir()
        dbdir = os.path.join(tempdir, "postgis")
        socket_dir = tempdir

        _postgres_server = PostgreSQLServer(dbdir, 6543, find_postgis_sql(),
                                            socket_dir = socket_dir)
        _postgres_server.createdb()

    return _postgres_server

def shutdown_test_server():
    """Shutdown the test server if it is running"""
    global _postgres_server
    if _postgres_server is not None:
        _postgres_server.shutdown()
        _postgres_server = None


def reason_for_not_running_tests():
    """
    Determine whether postgis tests can be run and return a reason they can't

    There's no fool-proof way to reliably determine this short of
    actually running the tests but we try the following here:

     - test whether pg_ctl --help can be run successfully
     - test whether the postgis_sql can be opened
       The name of the postgis_sql file is determined by find_postgis_sql()
     - psycopg can be imported successfully.
    """
    try:
        run_command(["pg_ctl", "--help"], None)
    except RuntimeError:
        return "Can't run PostGIS tests because pg_ctl fails"

    try:
        postgis_sql = find_postgis_sql()
    except:
        return "Can't run PostGIS tests because postgis.sql can't be found"

    try:
        f = open(postgis_sql)
        f.close()
    except:
        return "Can't run PostGIS tests because postgis.sql can't be opened"

    # The test for psycopg was already done when this module was
    # imported so we only have to check whether it was successful
    if psycopg is None:
        return "Can't run PostGIS tests because psycopg can't be imported"

    return ""


_cannot_run_postgis_tests = None
def skip_if_no_postgis():
    global _cannot_run_postgis_tests
    if _cannot_run_postgis_tests is None:
        _cannot_run_postgis_tests = reason_for_not_running_tests()
    if _cannot_run_postgis_tests:
        raise support.SkipTest(_cannot_run_postgis_tests)

def point_to_wkt(coords):
    """Return string with a WKT representation of the point in coords"""
    x, y = coords[0]
    return "POINT(%r %r)" % (x, y)

def polygon_to_wkt(coords):
    """Return string with a WKT representation of the polygon in coords"""
    poly = []
    for ring in coords:
        poly.append(", ".join(["%r %r" % p for p in ring]))
    return "POLYGON((%s))" % "), (".join(poly)

def arc_to_wkt(coords):
    """Return string with a WKT representation of the arc in coords"""
    poly = []
    for ring in coords:
        poly.append(", ".join(["%r %r" % p for p in ring]))
    return "MULTILINESTRING((%s))" % "), (".join(poly)

def upload_shapefile(filename, db, tablename):
    import dbflib, shapelib

    server = db.server
    dbname = db.dbname
    conn = psycopg.connect("host=%s port=%s dbname=%s"
                           % (server.host, server.port, dbname))
    cursor = conn.cursor()

    shp = shapelib.ShapeFile(filename)
    dbf = dbflib.DBFFile(filename)
    typemap = {dbflib.FTString: "VARCHAR",
               dbflib.FTInteger: "INTEGER",
               dbflib.FTDouble: "DOUBLE PRECISION"}

    insert_formats = ["%(gid)s"]
    fields = ["gid INT"]
    for i in range(dbf.field_count()):
        ftype, name, width, prec = dbf.field_info(i)
        fields.append("%s %s" % (name, typemap[ftype]))
        insert_formats.append("%%(%s)s" % name)
    stmt = "CREATE TABLE %s (\n    %s\n);" % (tablename,
                                              ",\n    ".join(fields))
    cursor.execute(stmt)
    #print stmt

    numshapes, shapetype, mins, maxs = shp.info()
    if shapetype == shapelib.SHPT_POINT:
        convert = point_to_wkt
        wkttype = "POINT"
    elif shapetype == shapelib.SHPT_POLYGON:
        convert = polygon_to_wkt
        wkttype = "POLYGON"
    elif shapetype == shapelib.SHPT_ARC:
        convert = arc_to_wkt
        wkttype = "MULTILINESTRING"
    else:
        raise ValueError("Unsupported Shapetype %r" % shapetype)

    cursor.execute("select AddGeometryColumn('%(dbname)s',"
                   "'%(tablename)s', 'the_geom', '-1', '%(wkttype)s', 2);"
                   % locals())

    insert_formats.append("GeometryFromText(%(the_geom)s, -1)")

    insert = ("INSERT INTO %s VALUES (%s)"
              % (tablename, ", ".join(insert_formats)))

    for i in range(numshapes):
        data = dbf.read_record(i)
        data["tablename"] = tablename
        data["gid"] = i
        data["the_geom"] = convert(shp.read_object(i).vertices())
        #print insert % data
        cursor.execute(insert, data)

    conn.commit()
1	bh	1605	# Copyright (C) 2003 by Intevation GmbH
2			# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with the software for details.
7
8			"""Support module for tests that use a live PostGIS database"""
9
10			__version__ = "$Revision$"
11			# $Source$
12			# $Id$
13
14			import sys
15			import os
16			import time
17			import popen2
18			import shutil
19			import traceback
20
21			import support
22
23			try:
24			import psycopg
25			except ImportError:
26			psycopg = None
27
28			#
29			# Helper code
30			#
31
32			def run_config_script(cmdline):
33			"""Run command cmdline and return its stdout or none in case of errors"""
34			pipe = os.popen(cmdline)
35			result = pipe.read()
36			if pipe.close() is not None:
37			raise RuntimeError('Command %r failed' % cmdline)
38			return result
39
40			def run_command(command, outfilename = None):
41			"""Run command as a subprocess and send its stdout and stderr to outfile
42
43			The subprocess is run synchroneously so the function returns once
44			the subprocess has termninated. If the process' exit code is not
45			zero raise a RuntimeError.
46
47			If outfilename is None stdout and stderr are still captured but they
48			are ignored and not written to any file.
49			"""
50			proc = popen2.Popen4(command)
51			proc.tochild.close()
52			output = proc.fromchild.read()
53			status = proc.wait()
54			if outfilename is not None:
55			outfile = open(outfilename, "w")
56			outfile.write(output)
57			outfile.close()
58			if not os.WIFEXITED(status) or os.WEXITSTATUS(status) != 0:
59			if outfilename:
60			message = "see %s" % outfilename
61			else:
62			message = output
63			raise RuntimeError("command %r exited with code %d.\n%s"
64			% (command, status, message))
65
66
67			def run_boolean_command(command):
68			"""
69			Run command as a subprocess silently and return whether it ran successfully
70
71			Silently means that all output is captured and ignored. The exit
72			status is true if the command ran successfull, i.e. it terminated by
73			exiting and returned as zero exit code and false other wise
74			"""
75			try:
76			run_command(command, None)
77			return 1
78			except RuntimeError:
79			pass
80			return 0
81
82
83			#
84			# PostgreSQL and database
85			#
86
87			class PostgreSQLServer:
88
89			"""A PostgreSQL server
90
91			Instances of this class represent a PostgreSQL server with postgis
92			extensions run explicitly for the test cases. Such a server has its
93			own database directory and its own directory for the unix sockets so
94			that it doesn't interfere with any other PostgreSQL server already
95			running on the system.
96			"""
97
98			def __init__(self, dbdir, port, postgis_sql, socket_dir):
99			"""Initialize the PostgreSQLServer object
100
101			Parameters:
102
103			dbdir -- The directory for the databases
104			port -- The port to use
105			postgis_sql -- The name of the file with the SQL statements to
106			initialize a database for postgis.
107			socket_dir -- The directory for the socket files.
108
109			When connecting to the database server use the port and host
110			instance variables.
111			"""
112			self.dbdir = dbdir
113			self.port = port
114			self.postgis_sql = postgis_sql
115			self.socket_dir = socket_dir
116
117			# For the client side the socket directory can be used as the
118			# host the name starts with a slash.
119			self.host = os.path.abspath(socket_dir)
120
121			# Map db names to db objects
122			self.known_dbs = {}
123
124			def createdb(self):
125			"""Create the database in dbdir and start the server.
126
127			First check whether the dbdir already exists and if necessary
128			stop an already running postmaster and remove the dbdir
129			directory completely. Then create a new database cluster in the
130			dbdir and start a postmaster.
131			"""
132			if os.path.isdir(self.dbdir):
133			if self.is_running():
134			self.shutdown()
135			shutil.rmtree(self.dbdir)
136			os.mkdir(self.dbdir)
137
138			run_command(["initdb", self.dbdir],
139			os.path.join(self.dbdir, "initdb.log"))
140
141			extra_opts = "-p %d" % self.port
142			if self.socket_dir is not None:
143			extra_opts += " -k %s" % self.socket_dir
144			run_command(["pg_ctl", "-D", self.dbdir,
145			"-l", os.path.join(self.dbdir, "logfile"),
146			"-o", extra_opts, "start"],
147			os.path.join(self.dbdir, "pg_ctl-start.log"))
148			# the -w option of pg_ctl doesn't work properly when the port is
149			# not the default port, so we have to implement waiting for the
150			# server ourselves
151			self.wait_for_postmaster()
152
153			def wait_for_postmaster(self):
154			"""Return when the database server is running
155
156			Internal method to wait until the postmaster process has been
157			started and is ready for client connections.
158			"""
159			max_count = 60
160			count = 0
161			while count < max_count:
162			try:
163			run_command(["psql", "-l", "-p", str(self.port),
164			"-h", self.host],
165			os.path.join(self.dbdir, "psql-%d.log" % count))
166			except:
167			pass
168			else:
169			break
170			time.sleep(0.5)
171			count += 1
172			else:
173			raise RuntimeError("postmaster didn't start")
174
175			def is_running(self):
176			"""Return true a postmaster process is running on self.dbdir
177
178			This method runs pg_ctl status on the dbdir so even if the
179			object has just been created it is possible that this method
180			returns true if there's still a postmaster process running for
181			self.dbdir.
182			"""
183			return run_boolean_command(["pg_ctl", "-D", self.dbdir, "status"])
184
185			def shutdown(self):
186			"""Stop the postmaster running for self.dbdir"""
187			run_command(["pg_ctl", "-m", "fast", "-D", self.dbdir, "stop"],
188			os.path.join(self.dbdir, "pg_ctl-stop.log"))
189
190			def new_postgis_db(self, dbname, tables = None):
191			"""Create and return a new PostGISDatabase object using self as server
192			"""
193			db = PostGISDatabase(self, self.postgis_sql, dbname, tables = tables)
194			db.initdb()
195			self.known_dbs[dbname] = db
196			return db
197
198			def get_static_data_db(self, dbname, tables):
199			"""Return a PostGISDatabase for a database with the given static data
200
201			If no databasse of the name dbname exists, create a new one via
202			new_postgis_db and upload the data.
203
204			If a database of the name dbname already exists and uses the
205			indicated data, return that. If the already existing db uses
206			different data raise a value error.
207
208			The tables argument should be a sequence of table specifications
209			where each specifications is a (tablename, shapefilename) pair.
210			"""
211			db = self.known_dbs.get(dbname)
212			if db is not None:
213			if db.has_data(tables):
214			return db
215			raise ValueError("PostGISDatabase named %r doesn't have tables %r"
216			% (dbname, tables))
217			return self.new_postgis_db(dbname, tables)
218
219			def get_default_static_data_db(self):
220			dbname = "PostGISStaticTests"
221			tables = [("landmarks", os.path.join("..", "Data", "iceland",
222			"cultural_landmark-point.shp")),
223			("political", os.path.join("..", "Data", "iceland",
224			"political.shp")),
225			("roads", os.path.join("..", "Data", "iceland",
226			"roads-line.shp"))]
227			return self.get_static_data_db(dbname, tables)
228
229
230
231
232			class PostGISDatabase:
233
234			"""A PostGIS database in a PostgreSQLServer"""
235
236			def __init__(self, server, postgis_sql, dbname, tables = None):
237			self.server = server
238			self.postgis_sql = postgis_sql
239			self.dbname = dbname
240			self.tables = tables
241
242			def initdb(self):
243			"""Remove the old db directory and create and initialize a new database
244			"""
245			run_command(["createdb", "-p", str(self.server.port),
246			"-h", self.server.host, self.dbname],
247			os.path.join(self.server.dbdir, "createdb.log"))
248			run_command(["createlang", "-p", str(self.server.port),
249			"-h", self.server.host, "plpgsql", self.dbname],
250			os.path.join(self.server.dbdir, "createlang.log"))
251			# for some reason psql doesn't exit with an error code if the
252			# file given as -f doesn't exist, so we check manually by trying
253			# to open it before we run psql
254			f = open(self.postgis_sql)
255			f.close()
256			del f
257			run_command(["psql", "-f", self.postgis_sql, "-d", self.dbname,
258			"-p", str(self.server.port), "-h", self.server.host],
259			os.path.join(self.server.dbdir, "psql.log"))
260
261			if self.tables is not None:
262			for tablename, shapefile in self.tables:
263			upload_shapefile(shapefile, self, tablename)
264
265			def has_data(self, tables):
266			return self.tables == tables
267
268
269			def find_postgis_sql():
270			"""Return the name of the postgis_sql file
271
272			A postgis installation usually has the postgis_sql file in
273			PostgreSQL's datadir (i.e. the directory where PostgreSQL keeps
274			static files, not the directory containing the databases).
275			Unfortunately there's no way to determine the name of this directory
276			with pg_config so we assume here that it's
277			$bindir/../share/postgresql/.
278			"""
279			bindir = run_config_script("pg_config --bindir").strip()
280			return os.path.join(bindir, "..", "share", "postgresql",
281			"contrib", "postgis.sql")
282
283			_postgres_server = None
284			def get_test_server():
285			"""Return the test database server object.
286
287			If it doesn't exist yet, create it first.
288
289			The server will use the directory postgis under the temp dir (as
290			defined by support.create_temp_dir()) for the database cluster.
291			Sockets will be created in tempdir.
292			"""
293			global _postgres_server
294			if _postgres_server is None:
295			tempdir = support.create_temp_dir()
296			dbdir = os.path.join(tempdir, "postgis")
297			socket_dir = tempdir
298
299			_postgres_server = PostgreSQLServer(dbdir, 6543, find_postgis_sql(),
300			socket_dir = socket_dir)
301			_postgres_server.createdb()
302
303			return _postgres_server
304
305			def shutdown_test_server():
306			"""Shutdown the test server if it is running"""
307			global _postgres_server
308			if _postgres_server is not None:
309			_postgres_server.shutdown()
310			_postgres_server = None
311
312
313			def reason_for_not_running_tests():
314			"""
315			Determine whether postgis tests can be run and return a reason they can't
316
317			There's no fool-proof way to reliably determine this short of
318			actually running the tests but we try the following here:
319
320			- test whether pg_ctl --help can be run successfully
321			- test whether the postgis_sql can be opened
322			The name of the postgis_sql file is determined by find_postgis_sql()
323			- psycopg can be imported successfully.
324			"""
325			try:
326			run_command(["pg_ctl", "--help"], None)
327			except RuntimeError:
328			return "Can't run PostGIS tests because pg_ctl fails"
329
330			try:
331			postgis_sql = find_postgis_sql()
332			except:
333			return "Can't run PostGIS tests because postgis.sql can't be found"
334
335			try:
336			f = open(postgis_sql)
337			f.close()
338			except:
339			return "Can't run PostGIS tests because postgis.sql can't be opened"
340
341			# The test for psycopg was already done when this module was
342			# imported so we only have to check whether it was successful
343			if psycopg is None:
344			return "Can't run PostGIS tests because psycopg can't be imported"
345
346			return ""
347
348
349			_cannot_run_postgis_tests = None
350			def skip_if_no_postgis():
351			global _cannot_run_postgis_tests
352			if _cannot_run_postgis_tests is None:
353			_cannot_run_postgis_tests = reason_for_not_running_tests()
354			if _cannot_run_postgis_tests:
355			raise support.SkipTest(_cannot_run_postgis_tests)
356
357			def point_to_wkt(coords):
358			"""Return string with a WKT representation of the point in coords"""
359			x, y = coords[0]
360			return "POINT(%r %r)" % (x, y)
361
362			def polygon_to_wkt(coords):
363			"""Return string with a WKT representation of the polygon in coords"""
364			poly = []
365			for ring in coords:
366			poly.append(", ".join(["%r %r" % p for p in ring]))
367			return "POLYGON((%s))" % "), (".join(poly)
368
369			def arc_to_wkt(coords):
370			"""Return string with a WKT representation of the arc in coords"""
371			poly = []
372			for ring in coords:
373			poly.append(", ".join(["%r %r" % p for p in ring]))
374			return "MULTILINESTRING((%s))" % "), (".join(poly)
375
376			def upload_shapefile(filename, db, tablename):
377			import dbflib, shapelib
378
379			server = db.server
380			dbname = db.dbname
381			conn = psycopg.connect("host=%s port=%s dbname=%s"
382			% (server.host, server.port, dbname))
383			cursor = conn.cursor()
384
385			shp = shapelib.ShapeFile(filename)
386			dbf = dbflib.DBFFile(filename)
387			typemap = {dbflib.FTString: "VARCHAR",
388			dbflib.FTInteger: "INTEGER",
389			dbflib.FTDouble: "DOUBLE PRECISION"}
390
391			insert_formats = ["%(gid)s"]
392			fields = ["gid INT"]
393			for i in range(dbf.field_count()):
394			ftype, name, width, prec = dbf.field_info(i)
395			fields.append("%s %s" % (name, typemap[ftype]))
396			insert_formats.append("%%(%s)s" % name)
397			stmt = "CREATE TABLE %s (\n %s\n);" % (tablename,
398			",\n ".join(fields))
399			cursor.execute(stmt)
400			#print stmt
401
402			numshapes, shapetype, mins, maxs = shp.info()
403			if shapetype == shapelib.SHPT_POINT:
404			convert = point_to_wkt
405			wkttype = "POINT"
406			elif shapetype == shapelib.SHPT_POLYGON:
407			convert = polygon_to_wkt
408			wkttype = "POLYGON"
409			elif shapetype == shapelib.SHPT_ARC:
410			convert = arc_to_wkt
411			wkttype = "MULTILINESTRING"
412			else:
413			raise ValueError("Unsupported Shapetype %r" % shapetype)
414
415			cursor.execute("select AddGeometryColumn('%(dbname)s',"
416			"'%(tablename)s', 'the_geom', '-1', '%(wkttype)s', 2);"
417			% locals())
418
419			insert_formats.append("GeometryFromText(%(the_geom)s, -1)")
420
421			insert = ("INSERT INTO %s VALUES (%s)"
422			% (tablename, ", ".join(insert_formats)))
423
424			for i in range(numshapes):
425			data = dbf.read_record(i)
426			data["tablename"] = tablename
427			data["gid"] = i
428			data["the_geom"] = convert(shp.read_object(i).vertices())
429			#print insert % data
430			cursor.execute(insert, data)
431
432			conn.commit()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision