/[thuban]/branches/WIP-pyshapelib-bramz/test/postgissupport.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/test/postgissupport.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2057 by bh, Tue Feb 10 15:51:57 2004 UTC revision 2459 by bh, Wed Dec 15 11:12:11 2004 UTC
# Line 184  class PostgreSQLServer: Line 184  class PostgreSQLServer:
184              raise RuntimeError("postmaster didn't start")              raise RuntimeError("postmaster didn't start")
185    
186      def is_running(self):      def is_running(self):
187          """Return true a postmaster process is running on self.dbdir          """Return whether a postmaster process is running on self.dbdir
188    
189          This method runs pg_ctl status on the dbdir so even if the          This method runs pg_ctl status on the dbdir and returns True if
190          object has just been created it is possible that this method          that command succeeds and False otherwise.
191          returns true if there's still a postmaster process running for  
192          self.dbdir.          Note that it is possible that this method returns true even if
193            the PostgreSQLServer instance has just been created and
194            createdb() has not been called yet.  This can happen, for
195            instance, if the server has been started manually for debugging
196            purposes after a test suite run.
197          """          """
198          return run_boolean_command(["pg_ctl", "-D", self.dbdir, "status"])          return run_boolean_command(["pg_ctl", "-D", self.dbdir, "status"])
199    
# Line 198  class PostgreSQLServer: Line 202  class PostgreSQLServer:
202          run_command(["pg_ctl", "-m", "fast", "-D", self.dbdir, "stop"],          run_command(["pg_ctl", "-m", "fast", "-D", self.dbdir, "stop"],
203                      os.path.join(self.dbdir, "pg_ctl-stop.log"))                      os.path.join(self.dbdir, "pg_ctl-stop.log"))
204    
205      def new_postgis_db(self, dbname, tables = None, reference_systems = None):      def new_postgis_db(self, dbname, tables = None, reference_systems = None,
206                           views = None):
207          """Create and return a new PostGISDatabase object using self as server          """Create and return a new PostGISDatabase object using self as server
208          """          """
209          db = PostGISDatabase(self, self.postgis_sql, dbname, tables = tables,          db = PostGISDatabase(self, self.postgis_sql, dbname, tables = tables,
210                               reference_systems = reference_systems)                               reference_systems = reference_systems,
211                                 views = views)
212          db.initdb()          db.initdb()
213          self.known_dbs[dbname] = db          self.known_dbs[dbname] = db
214          return db          return db
215    
216      def get_static_data_db(self, dbname, tables, reference_systems):      def get_static_data_db(self, dbname, tables, reference_systems, views):
217          """Return a PostGISDatabase for a database with the given static data          """Return a PostGISDatabase for a database with the given static data
218    
219          If no databasse of the name dbname exists, create a new one via          If no databasse of the name dbname exists, create a new one via
# Line 225  class PostgreSQLServer: Line 231  class PostgreSQLServer:
231          """          """
232          db = self.known_dbs.get(dbname)          db = self.known_dbs.get(dbname)
233          if db is not None:          if db is not None:
234              if db.has_data(tables, reference_systems):              if db.has_data(tables, reference_systems, views):
235                  return db                  return db
236              raise ValueError("PostGISDatabase named %r doesn't have tables %r"              raise ValueError("PostGISDatabase named %r doesn't have tables %r"
237                               % (dbname, tables))                               % (dbname, tables))
238          return self.new_postgis_db(dbname, tables, reference_systems)          return self.new_postgis_db(dbname, tables, reference_systems, views)
239    
240      def get_default_static_data_db(self):      def get_default_static_data_db(self):
241          dbname = "PostGISStaticTests"          dbname = "PostGISStaticTests"
# Line 237  class PostgreSQLServer: Line 243  class PostgreSQLServer:
243          tables = [          tables = [
244              # Direct copies of the shapefiles. The shapeids are exactly              # Direct copies of the shapefiles. The shapeids are exactly
245              # the same, except where changed with "gid_offset", of              # the same, except where changed with "gid_offset", of
246              # course              # course.  Note that the test implementation requires that
247                # all the landmard tables use an gid_offset of 1000.
248              ("landmarks", os.path.join("..", "Data", "iceland",              ("landmarks", os.path.join("..", "Data", "iceland",
249                                         "cultural_landmark-point.shp"),                                         "cultural_landmark-point.shp"),
250               [("gid_offset", 1000)]),               [("gid_offset", 1000)]),
# Line 251  class PostgreSQLServer: Line 258  class PostgreSQLServer:
258                                               "political.shp"),                                               "political.shp"),
259               [("force_wkt_type", "MULTIPOLYGON")]),               [("force_wkt_type", "MULTIPOLYGON")]),
260    
261              # Copy of landmarks but using an srid              # Copy of landmarks but using an srid != -1
262              ("landmarks_srid", os.path.join("..", "Data", "iceland",              ("landmarks_srid", os.path.join("..", "Data", "iceland",
263                                         "cultural_landmark-point.shp"),                                         "cultural_landmark-point.shp"),
264               [("gid_offset", 1000),               [("gid_offset", 1000),
265                ("srid", 1)]),                ("srid", 1)]),
266    
267                # Copy of landmarks with a gid column called "point_id" instead
268                # of "gid" and using an srid != -1.
269                ("landmarks_point_id", os.path.join("..", "Data", "iceland",
270                                                    "cultural_landmark-point.shp"),
271                 [("gid_offset", 1000),
272                  ("srid", 1),
273                  ("gid_column", "point_id")]),
274              ]              ]
275          return self.get_static_data_db(dbname, tables, srids)          views = [("v_landmarks", "SELECT * FROM landmarks_point_id")]
276            return self.get_static_data_db(dbname, tables, srids, views)
277    
278      def connection_params(self, user):      def connection_params(self, user):
279          """Return the connection parameters for the given user          """Return the connection parameters for the given user
# Line 336  class PostGISDatabase: Line 352  class PostGISDatabase:
352      """A PostGIS database in a PostgreSQLServer"""      """A PostGIS database in a PostgreSQLServer"""
353    
354      def __init__(self, server, postgis_sql, dbname, tables = None,      def __init__(self, server, postgis_sql, dbname, tables = None,
355                   reference_systems = ()):                   reference_systems = (), views = None):
356          """Initialize the PostGISDatabase          """Initialize the PostGISDatabase
357    
358          Parameters:          Parameters:
# Line 362  class PostGISDatabase: Line 378  class PostGISDatabase:
378                  (srid, params) pairs where srid is the srid defined by                  (srid, params) pairs where srid is the srid defined by
379                  the proj4 paramter string params.  The srid can be given                  the proj4 paramter string params.  The srid can be given
380                  as an extra parameter in the tables list.                  as an extra parameter in the tables list.
381    
382                views -- Optional description of views.  If given it should
383                    be a list of (viewname, select_stmt) pairs where
384                    viewname is the name of the view to be created and
385                    select_stmt is the select statement to use as the basis.
386                    The views will be created after the tables and may refer
387                    to them in the select_stmt.
388          """          """
389          self.server = server          self.server = server
390          self.postgis_sql = postgis_sql          self.postgis_sql = postgis_sql
391          self.dbname = dbname          self.dbname = dbname
392          self.tables = tables          self.tables = tables
393            self.views = views
394          if reference_systems:          if reference_systems:
395              self.reference_systems = reference_systems              self.reference_systems = reference_systems
396          else:          else:
# Line 422  class PostGISDatabase: Line 446  class PostGISDatabase:
446                  tablename, shapefile, kw = unpack(info)                  tablename, shapefile, kw = unpack(info)
447                  upload_shapefile(shapefile, self, tablename, **kw)                  upload_shapefile(shapefile, self, tablename, **kw)
448    
449      def has_data(self, tables, reference_systems):          if self.views is not None:
450                for viewname, select_stmt in self.views:
451                    self.server.execute_sql(self.dbname, "admin",
452                                            "CREATE VIEW %s AS %s" % (viewname,
453                                                                      select_stmt))
454                    self.server.execute_sql(self.dbname, "admin",
455                                            "GRANT SELECT ON %s TO PUBLIC;"
456                                            % viewname)
457    
458        def has_data(self, tables, reference_systems, views):
459          return (self.tables == tables          return (self.tables == tables
460                  and self.reference_systems == reference_systems)                  and self.reference_systems == reference_systems
461                    and self.views == views)
462    
463    
464  def find_postgis_sql():  def find_postgis_sql():
# Line 529  def skip_if_addgeometrycolumn_does_not_u Line 563  def skip_if_addgeometrycolumn_does_not_u
563    
564      The test performed by this function is a bit simplistic because it      The test performed by this function is a bit simplistic because it
565      only tests whether the string 'quote_ident' occurs anywhere in the      only tests whether the string 'quote_ident' occurs anywhere in the
566      postgis.sql file. This will hopefully works because when this was      postgis.sql file. This will hopefully work because when this was
567      fixed in postgis CVS AddGeometryColumn was the first function to use      fixed in postgis CVS AddGeometryColumn was the first function to use
568      quote_ident.      quote_ident.
569      """      """
# Line 573  wkt_converter = { Line 607  wkt_converter = {
607      }      }
608    
609  def upload_shapefile(filename, db, tablename, force_wkt_type = None,  def upload_shapefile(filename, db, tablename, force_wkt_type = None,
610                       gid_offset = 0, srid = -1):                       gid_offset = 0, gid_column = "gid", srid = -1):
611      """Upload a shapefile into a new database table      """Upload a shapefile into a new database table
612    
613      Parameters:      Parameters:
# Line 592  def upload_shapefile(filename, db, table Line 626  def upload_shapefile(filename, db, table
626      gid_offset -- A number to add to the shapeid to get the value for      gid_offset -- A number to add to the shapeid to get the value for
627                  the gid column (default 0)                  the gid column (default 0)
628    
629        gid_column -- The name of the column with the shape ids.  Default
630                      'gid'.  If None, no gid column will be created.  The
631                      name is directly used in SQL statements, so if it
632                      contains unusualy characters the caller should provide
633                      a suitable quoted string.
634    
635      srid -- The srid of the spatial references system used by the table      srid -- The srid of the spatial references system used by the table
636              and the data              and the data
637      """      """
# Line 618  def upload_shapefile(filename, db, table Line 658  def upload_shapefile(filename, db, table
658                 dbflib.FTInteger: "INTEGER",                 dbflib.FTInteger: "INTEGER",
659                 dbflib.FTDouble: "DOUBLE PRECISION"}                 dbflib.FTDouble: "DOUBLE PRECISION"}
660    
661      insert_formats = ["%(gid)s"]      insert_formats = []
662      fields = ["gid INT"]      if gid_column:
663            insert_formats.append("%(gid)s")
664    
665        fields = []
666        fields_decl = []
667        if gid_column:
668            fields.append(gid_column)
669            fields_decl.append("%s INT" % gid_column)
670      for i in range(dbf.field_count()):      for i in range(dbf.field_count()):
671          ftype, name, width, prec = dbf.field_info(i)          ftype, name, width, prec = dbf.field_info(i)
672          fields.append("%s %s" % (name, typemap[ftype]))          fields.append(name)
673            fields_decl.append("%s %s" % (name, typemap[ftype]))
674          insert_formats.append("%%(%s)s" % name)          insert_formats.append("%%(%s)s" % name)
675      stmt = "CREATE TABLE %s (\n    %s\n);" % (tablename,      stmt = "CREATE TABLE %s (\n    %s\n);" % (tablename,
676                                                ",\n    ".join(fields))                                                ",\n    ".join(fields_decl))
677      cursor.execute(stmt)      cursor.execute(stmt)
678      #print stmt      #print stmt
679    
# Line 638  def upload_shapefile(filename, db, table Line 686  def upload_shapefile(filename, db, table
686      cursor.execute("select AddGeometryColumn('%(dbname)s',"      cursor.execute("select AddGeometryColumn('%(dbname)s',"
687                     "'%(tablename)s', 'the_geom', %(srid)d, '%(wkttype)s', 2);"                     "'%(tablename)s', 'the_geom', %(srid)d, '%(wkttype)s', 2);"
688                     % locals())                     % locals())
689        fields.append("the_geom")
690      insert_formats.append("GeometryFromText(%(the_geom)s, %(srid)d)")      insert_formats.append("GeometryFromText(%(the_geom)s, %(srid)d)")
691    
692      insert = ("INSERT INTO %s VALUES (%s)"      insert = ("INSERT INTO %s (%s) VALUES (%s)"
693                % (tablename, ", ".join(insert_formats)))                % (tablename, ", ".join(fields), ", ".join(insert_formats)))
694    
695      for i in range(numshapes):      for i in range(numshapes):
696          data = dbf.read_record(i)          data = dbf.read_record(i)
697          data["tablename"] = tablename          data["tablename"] = tablename
698          data["gid"] = i + gid_offset          if gid_column:
699                data["gid"] = i + gid_offset
700          data["srid"] = srid          data["srid"] = srid
701          data["the_geom"] = convert(shp.read_object(i).vertices())          data["the_geom"] = convert(shp.read_object(i).vertices())
702          #print insert % data          #print insert % data
Legend:
Removed from v.2057  
changed lines
  Added in v.2459
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26